二分查找算法

只要有二段性,就可以使用二分查找

二分查找

算法流程：

1. 定义 left ， right 指针，分别指向数组的左右区间。
2. 找到待查找区间的中间点 mid ，找到之后分三种情况讨论：

• nums[mid] == target 说明正好找到，返回 mid 的值；
• nums[mid] > target 说明 [mid, right] 这段区间都是大于 target 的，因此舍
  去右边区间，在左边 [left, mid -1] 的区间继续查找，即让 right = mid -
  1 ，然后重复 2 过程；
• nums[mid] < target 说明 [left, mid] 这段区间的值都是小于 target 的，因
  此舍去左边区间，在右边 [mid + 1, right] 区间继续查找，即让 left = mid +
  1 ，然后重复 2 过程；

3. 当 left 与 right 错开时，说明整个区间都没有这个数，返回 -1 。

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

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

算法思路：
用的还是二分思想，就是根据数据的性质，在某种判断条件下将区间⼀分为二，舍去其中⼀个区间，然后在另⼀个区间内查找
为了方便叙述，用 target 表示目标元素， left 表示查找区间左边界， right 表示查找区间右边界。
resLeft表示目标元素左边界,resRight表示目标元素右边界

寻找resLeft思路：
▪ 左边区间 [left, resLeft - 1] 都是小于 target 的；
▪ 右边区间（包括左边界） [resLeft, right] 都是大于等于 target 的；

因此，关于 mid 的落点，我们可以分为下面两种情况：

• 当 mid 落在 [left, resLeft - 1] 区间的时候，也就是 nums[mid] < target 。说明 [left, mid] 都是可以舍去的，此时更新 left 到 mid + 1 的位置，继续在 [mid + 1, right] 上寻找左边界；
• 当 mid 落在 [resLeft， right] 的区间的时候，也就是 nums[mid] >= target 。说明 [mid + 1, right] （因为 mid 可能是最终结果，不能舍去）是可以舍去的，此时更新 right 到 mid 的位置，继续在 [left, mid] 上寻找左边界

注意：这里找中间元素需要向下取整。

如果mid = left + (right - left) / 2 ,上图中 mid就是left,就不会死循环
如果mid = left + (right - left+1) / 2 ,上图中 mid就是right,nums[mid] >=target,right = mid陷入死循环

寻找resRight思路：

▪ 左边区间 （包括右边界） [left, resRight] 都是小于等于 target 的；
▪ 右边区间 [resRight+ 1, right] 都是大于 target 的；

因此，关于 mid 的落点，我们可以分为下面两种情况：

• 当 mid 落在 [left, resRight] 区间的时候，也就是 nums[mid] <= target ,说明 [left, mid - 1]（ mid 不可以舍去，因为有可能是最终结果） 都是可以舍去的，此时更新 left 到 mid的位置
• 当 mid 落在 [resRight+ 1, right] 区间的时候，也就是 nums[mid] > target, 说明 [mid, right] 内的元素是可以舍去的，此时更新 right 到 mid - 1 的位置；

注意：这里找中间元素需要向上取整。

如果mid = left + (right - left) / 2 ,上图中 mid就是left,nums[mid] <=target,left = mid陷入死循环
如果mid = left + (right - left+1) / 2 ,上图中 mid就是right,就不会陷入死循环

查找区间左端点的模版:

	while (left < right) {
            int mid = left + (right - left) / 2;
            if(...) left = mid + 1;
            else right = mid;
        }

查找区间右端点的模版:

	 while (left < right) {
            int mid = left + (right - left + 1) / 2;
            if(...) left = mid;
            else right = mid - 1;
        }

二分查找算法总结：
大家⼀定不要觉得背下模板就能解决所有二分问题。二分问题最重要的就是要分析题意，然后确定要搜索的区间，根据分析来写出二分查找算法的代码。

要分析题意，确定搜索区间，不要死记模板，不要看左闭右开什么乱七⼋糟的题解
要分析题意，确定搜索区间，不要死记模板，不要看左闭右开什么乱七⼋糟的题解
要分析题意，确定搜索区间，不要死记模板，不要看左闭右开什么乱七⼋糟的题解
重要的事情说三遍。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] ret = new int[2];
        ret[0] = ret[1] = -1;
        //处理极端情况
        if(nums.length == 0) return ret;

        //1.二分左端点
        int left = 0, right = nums.length-1;
        while(left < right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] < target) left = mid + 1;
            else right = mid;
        }
        //更新结果
        if(nums[left] != target) return ret;
        else ret[0] = left; 
        // 2. ⼆分右端点
        left = 0;
        right = nums.length - 1;
        while(left < right) {
            int mid = left + (right - left + 1) / 2;
            if(nums[mid] <= target) left = mid;
            else right = mid - 1;
        }  
        ret[1] = left;
        return ret;
    }
}

x的平方根

算法思路：
设最终结果为 index ：

• [0, index] 之间的元素，平方之后都是小于等于 x 的；
• [index + 1, x] 之间的元素，平方之后都是大于 x 的。

因此可以使用二分查找算法。

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

搜索插入位置

算法思路：

设目标位置的坐标为 index ，可以知道：

• [left, index - 1] 内的所有元素均是小于 target 的；
• [index, right] 内的所有元素均是大于等于 target 的。

1. 设 left 为本轮查询的左边界， right 为本轮查询的右边界。根据 mid 位置元素的信
   息，分析下⼀轮查询的区间：

• 当 nums[mid] >= target 时，说明 mid 落在了 [index, right] 区间上，mid 可能是最终结果，所以我们接下来查找的区间在 [left, mid] 上。因此，更新 right 到 mid 位置，继续查找。
• 当 nums[mid] < target 时，说明 mid 落在了 [left, index - 1] 区间上，所以我们接下来查找的区间在 [mid + 1, right] 上。因此，更新 left 到 mid + 1 的位置，继续查找。

2. 直到查找区间的长度变为 1 ，也就是 left == right 的时候， left 或者right 所在的位置就是我们要找的结果。

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

遍历结束的left或right是大于等于target区间最左边的那个数
加上if(nums[left] < target) return left + 1;只是为了nums =[1,3,5,6] target =7这样的没有大于target的数的情况

还可以这样:

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

山脉数组的峰顶索引

算法思路：
分析峰顶数据的特点，以及峰顶两旁数据的特点：

• 峰顶数据特点： arr[i] > arr[i - 1] && arr[i] > arr[i + 1] ；

• 峰顶左边的数据特点： arr[i] > arr[i - 1] && arr[i] < arr[i + 1] ，也就是
  呈现上升趋势；

• 峰顶右边数据的特点： arr[i] < arr[i - 1] && arr[i] > arr[i + 1] ，也就是
  呈现下降趋势。

1.找到升序区间的最右边

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
        int left = 1, right = arr.length-2;
        while(left < right) {
            int mid = left + (right-left+1) / 2;
            if(arr[mid] > arr[mid-1]) left = mid;
            else right = mid-1;
        }
        return left;
    }
}

2.找到降序区间的最左边

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
        int left = 1, right = arr.length-2;
        while(left < right) {
            int mid = left + (right-left) / 2;
            if(arr[mid] > arr[mid+1]) right = mid;
            else left = mid + 1;
        }
        return left;
    }
}

寻找峰值

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

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

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

算法思路：
题目中的数组如下图所示：

其中 c 就是我们要找的点。a是大于d的
二分的本质：找到⼀个判断标准，使得查找区间能够⼀分为二。通过图像我们可以发现，正常情况下 ab区间内的点都是严格大于 d 的， c 是严格小于 d 的(当cd 区间只有⼀个元素的时候， c 是可能等于d 的)。

因此，我们可以以d为基准划分下⼀次查询的区间：

• 当 mid 在 ab区间的时候，也就是 mid 位置的值大于 d，下⼀次查询区间在 [mid + 1，right] 上；
• 当 mid 在cd区间的时候，也就是 mid 位置的值小于等于 d，下次查询区间在 [left，mid] 上。当区间长度变成 1 的时候，就是我们要找的结果。

如果选a作为基准的话,极端情况下a就是要找的点,a就不大于cd了

class Solution {
    public int findMin(int[] nums) {
        int left = 0, right = nums.length - 1;
        int x = nums[right]; // 最后⼀个位置的值,也就是d
        while(left < right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] > x) left = mid + 1;
            else right = mid;
        }
        return nums[left];
    }
}

0〜n-1中缺失的数字

算法思路（二分查找算法）：
关于这道题，时间复杂度为 O(N) 的解法有很多种，比如直接遍历找结果,异或运算,高斯公式求和…

本文只讲解最优的二分法来解决这个问题。

在这个升序的数组中，我们发现：

• 在缺失位置的左边，数组内的元素都是与数组的下标相等的；
• 在缺失位置的右边，数组内的元素与数组下标是不相等的。

因此，我们可以利用这个「二段性」，来使用「二分查找」算法。

class Solution {
    public int takeAttendance(int[] records) {
        int left = 0, right = records.length - 1;
        while(left < right) {
            int mid = left + (right-left)/2;
            if(records[mid] == mid) left = mid + 1;
            else right = mid;
        }
        return records[left] == left ? left+1 : left;
    }
}