【刷题笔记】二分查找2

74. 搜索二维矩阵

刷到了一个非常有意思的题，分享给大家。

将原来的数组形式转化为矩阵形式，矩阵按照从左到右从上到下的方向递增，给定一个target，我们要做的是找一下，这个矩阵中是否包含这个target。

其实，如果我们把这个矩阵看成一个数组，则可以直接用二分查找。问题的关键是，怎么将其看成数组呢？如果仔细思考，不难发现一个规律：

我们可以按照从左至右从上至下的顺序，给矩阵设置一个下标：

根据下标，我们能发现这样一个规律：

设下标 x 的值为 ，行数为 m，列数为 n

则 =matrix[x/n][x%n]

通过这个规律，我们便可以利用二分查找在矩阵中查找目标值了。

    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length;
        int n = matrix[0].length;
        if (m == 1 && n == 1) {
            if (matrix[0][0] == target) {
                return true;
            } else {
                return false;
            }
        }
        int left = 0;
        int right = m * n - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (matrix[mid/n][mid%n] < target) {
                left = mid + 1;
            } else if (matrix[mid/n][mid%n] > target) {
                right = mid - 1;
            } else {
                return true;
            }
        }
        return false;
    }

81. 搜索旋转排序数组 II

这道题做了好长时间，一顿调试，感觉做起来没太大意义。

但是通过这道题，还是可以总结出一些点的：

1. 当出现这种螺旋数组的问题时，要找到两个升序空间 [left,mid]，[mid,right]

2. 如果出现，数组最后一个数和第一个数相等的情况，则可以让left往前走，直到left不与right相等。

3. 代码这个位置

    if(nums[mid] == target) {
        return true;
    }

可以改成

​
    if(nums[mid] == target || nums[mid] == target || nums[mid] == target) {
        return true;
    }

​

虽然写起来麻烦了，但是某些情况下可能少循环很多轮，就是代码变得多了些。其实，之前的二分查找题目都可以加上这句，以达到少跑几轮的目的。

下面是这道题目的解答：

    public boolean search(int[] nums, int target) {
        int len = nums.length;
        if(len == 1 && nums[0] == target) {
            return true;
        }
        if(len == 1 && nums[0] != target) {
            return false;
        }
        int left = 0;
        int right = len - 1;
        while(left <= right) {
            while(left < right && nums[left] == nums[right]) {
                left = left + 1;
            }
            int mid = (left + right) / 2;
            if(nums[mid] == target) {
                return true;
            }
            if(nums[left] <= nums[mid]) {
                if(target < nums[mid] && target >= nums[left]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if(target > nums[mid] && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            } 
        }
        return false;
    }

153. 寻找旋转排序数组中的最小值

一看到旋转数组的题，就要思考mid会落入哪个区间。因为这道题是找数组的最小值，没有一个固定的target，所以说算是变相减少了判断的过程。

首先，我们要判断，如果数组第一个数如果小于最后一个数的情况，即nums[0]<=nums[len-1]，说明旋转了len次。这样的话，第一个数就是最小的。

然后，就可以进入旋转数组的问题的环节了： 

(1) 通过判断nums[0]是否小于nums[mid]，即判断[0,mid]是否是一个升序区间，如果是的话，说明最小值一定不在这个区间，那么我们就让left=mid+1;

(2) 如果num[0] > nums[mid]，就说明mid落入了第二个升序区间，最小值一定在mid左侧，所以我们让right=mid-1;

(3) 有可能出现mid正好是最小值，但是我们仍然让right = mid - 1，会不会有问题？你可以模拟一下，最后left会通过二分查找再回到最小值处。当然，这个会浪费一些效率，所以你可以在进行right = mid - 1赋值之前判断一下，如果mid-1处的值大于mid，就说明mid处就是最小值所在。

    public int findMin(int[] nums) {
        int len = nums.length;
        if(nums[0] <= nums[len - 1]) {
            return nums[0];
        }
        int left = 0;
        int rigtht = len - 1;
        while(left <= rigtht) {
            int mid = (left + rigtht) / 2;
            if(nums[0] <= nums[mid]) {
                left = mid + 1;
            } else if(nums[mid] <= nums[rigtht]) {
                rigtht = mid - 1;
            }
        }
        return nums[left];
    }