【刷题笔记】二分查找

1. 什么是二分查找？

​​​​​​         对于一个有序数组（一般是升序），我们要从中找某个值，可以从两端双向寻找。二分查找的时间复杂度为O(logn)。所以，看到题目中包含以上信息，一般采用二分查找的方法。

首先以一道题开启今天的介绍：

704. 二分查找

        这道题就是一个二分查找的概念题。我们首先定义两个指针，分别指向数组第一个元素和最后一个元素，然后每次循环都看一下位于他们中间的元素与target的关系。如果nums[mid] < target，说明target位于 mid+1 和 right 之间，那么我们就让 left=mid+1；而如果nums[mid] > target，说明target位于 left 和 right-1 之间，那么我们就让 right=mid-1。如此循环下去，知道 left > right，退出循环。

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

69. x 的平方根 

        这道题是一道简单题，但是非常容易出错。首先，它是一道二分查找题，我们可以把 x 看作nums的索引，而 。但是要注意的是，原题给出的x范围 ，平方后的值是超过int的最大值的，所以在计算平方的时候要给它转成long，否则你得到的就有可能是个负值。

    public int mySqrt(int x) {
        int left = 0;
        int right = x;
        int index = 0;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if((long)mid*mid <= x) {
                left = mid + 1;
                index = mid;
            } else {
                right = mid - 1;
            }
        }
        return index;
    }

367. 有效的完全平方数

        这道题同上，都需要注意超出int界限的情况。

    public boolean isPerfectSquare(int num) {
        long left = 0l;
        long right = num;
        while(left <= right) {
            long mid = (left + right) / 2;
            if(mid * mid < num) {
                left = mid + 1;
            } else if (mid * mid > num) {
                right = mid - 1;
            } else {
                return true;
            }
        }
        return false;
    }

34. 在排序数组中查找元素的第一个和最后一个位置

        这道题要找的是升序数组中，某个元素第一次出现和最后一次出现的位置。

        所以，当我们再用二分查找的时候，找到了一个 “8” 但是这个 “8” 左右两侧可能还有数字 “8”，所以我们就需要以这个 “8” 为分界线，在其两侧分别再进行二分查找，找到最左和最右端的 “8”。

        具体做法就是，当在找最左端的 “8” 时，当 nums[mid]=8 的时候，就让 right=mid，否则的话就同正常二分查找一样操作；同理，在找最右端的 “8” 时，当 nums[mid]=8 的时候，就让 left=mid，这样即固定了寻找区间，又通过 left 和 right 保住了 “8”。但是有一点要特别注意，就是我们进行二分查找计算mid的时候正常都是向下取整，这个在获取左侧 “8” 没有问题，但是在右区间，如果还是向下取整是有问题的，大家感兴趣可以自己模拟一下。其实也容易理解，往右找其实是一个镜像操作，所以我们要向上取整，所以找右侧值的时候mid=(left+right+1)/2。

    public int[] searchRange(int[] nums, int target){
        int len = nums.length;
        if (len == 0) {
            return new int[]{-1, -1};
        }
        int left = searchLeft(nums, target, len);
        int right = searchRight(nums, target, len);
        return new int[]{left, right};

    }

    private int searchRight(int[] nums, int target, int len) {
        int left = 0;
        int right = len - 1;
        while (left < right) {
            int mid = (left + right + 1) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if(nums[mid] > target) {
                right = mid - 1;
            } else {
                left = mid;
            }
        }
        return nums[right] == target ? right : -1;
    }

    private int searchLeft(int[] nums, int target, int len) {
        int left = 0;
        int right = len - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if(nums[mid] > target) {
                right = mid - 1;
            } else {
                right = mid;
            }
        }
        return nums[left] == target ? left : -1;
    }

33. 搜索旋转排序数组

        这道题很绕，我们在做的时候很可能被众多的if-else绕进去，所以做题的时候一定要捋清楚。其实，这道题是有两个上升区间的，并且这两个上升区间有着关联，就是：

num[0]>=nums[len-1]

首先我们先进行一次二分查找，这次查找要么直接找到target，而如果没找到，则有可能出现几种情况：

（1）nums[mid]>=nums[0]，那么其实[0,mid]是一个升序空间，[mid,len-1]是先降后升的空间。这个时候，如果target处于[0,mid]，那么接下来直接二分查找就好了；但是，如果target处于[mid,len-1]，那么我们就可以先让left=mid+1，再去做一个二分查找，这个时候的mid值（索引）是大于上一轮循环中的mid值（索引）的。再进行判断，是否[0,mid]是一个升序空间，如果升序继续判断target是否处于[0,mid]，如此循环，相当于我们要尽量把target的值框进第一个升序空间中。

（2）如果很不幸，target不在第一个升序空间的范围内，那么，在某一轮循环中一定会出现nums[mid]<nums[0]，说明此时mid已经落入了第二个升序空间中，在第二个升序空间中，如果target处于[mid,len-1]（[mid,len-1]一定是一个升序空间），则可以进行二分查找。然而，如果target处于[left,mid]，则跟（1）的情况一致。我们只需要把target框进升序空间中。

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