二分查找的几类问题

二分查找的本质为维护[0, low)和(high, length-1]两个不同性质的区间作为循环不变量，通过循环检查剩余未定部分[low, high]的mid来拓展区间边界，当两个区间相遇时，则数组被划分为了两个不同性质的部分。

这种在循环过程中动态维护多个区间的边界的思想在数组相关算法题中比较常见，例如快排中的基于基准元素将数据划分为左右两部分，颜色分类等

1. 寻找目标值

题目简述：给定一个n个元素升序整型数组 nums，若目标值target存在则返回其下标，否则返回-1。leetcode链接
思路：二分查找。循环不变量[0, low)设定为小于target的区间，(high, length-1]为大于target的区间。初始时low=0，high=length-1。当low <= high时循环取mid进行比较并更新区间。

• 若nums[mid] == target，则找到了直接返回
• 若nums[mid] < target，则[0, mid]都小于target，更新区间边界low=mid+1
• 若nums[mid] > target，则[mid, length-1]都大于target，更新区间边界high=mid-1

当low > high循环结束时，根据两个区间的性质可知不存在target，返回-1

public int search(int[] nums, int target) {
    int low = 0, high = nums.length-1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (nums[mid] == target) return mid;
        //若mid元素小于target，则移动low指针到mid+1
        else if (nums[mid] < target) low = mid + 1;
        //若mid元素大于target，则移动high指针到mid - 1
        else high = mid - 1;
    }
    return -1;
}

二分查找过程中的循环不变量：无论对于严格升序数组还是非递减数组，在上述查找过程中始终满足：low指针左边的元素[0, low)都是小于target，high指针右边元素(high, length-1]都是大于target。牢记这一性质

2. 搜索插入位置

题目简述：给定一个严格升序数组，若目标值存在于数组中则返回其索引，否则返回其按顺序插入的位置（插入位置若有元素则后移） 。leetcode链接
思路：二分查找。插入位置即第一个大于target元素的位置，因此将循环不变量[0, low)设定为小于target的区间，(high, length-1]为大于target的区间。当low <= high时循环取mid进行比较，相等则直接返回，否则更新区间边界。当low > high时，根据区间性质可知low指向的就是所求位置。

public int searchInsert(int[] nums, int target) {
    int low = 0, high = nums.length - 1;
    while(low <= high) {
        int mid = (low + high) / 2;
        if(nums[mid] == target) return mid;
        else if (nums[mid] < target) low = mid + 1;
        else high = mid - 1;
    }
    //此时，low一定在high的右边，且low指针左边的元素一定都是小于target的元素，high指针右边一定都是大于target的元素，因此low指针指向的位置恰好是插入位置
    return low;
}

3. 第一个大于target的元素

题目简述：在一个非递减数组中寻找target的插入位置，若存在相同元素则插入到它们后面
思路：即寻找第一个大于target的元素的位置。因此我们需要将循环不变量[0, low）设定为小于等于target的元素，(high, length-1]为大于target的元素，则循环结束后low指向的元素即为第一个大于target的元素

public int searchInsert2(int[] nums, int target) {
    int low = 0, high = nums.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        //当nums[mid]小于等于target时，向右移动low
        //循环不变量：[0, low)：小于等于target的元素，(high, length-1]：大于target的元素
        if (nums[mid] <= target) low = mid + 1;
        else high = mid - 1;
    }
    return low;
}

如果是寻找最后一个小于target的元素呢？显然就是将循环不变量[0, low）设定为小于target的元素，(high, length-1]为大于等于target的元素，最后high指向的元素就是结果。

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

题目简述：在一个非递减数组中寻找一个值的起始位置和终止位置，不存在则返回[-1,-1]。leetcode链接
思路：起始位置i即第一个大于target-1的位置，终止位置j即第一个大于target的位置-1。若target不存在则i必定大于j

public int[] searchRange(int[] nums, int target) {
    int i = searchInsert2(nums, target-1);
    int j = searchInsert2(nums, target) - 1;
    return i <= j ? new int[]{i, j} : new int[]{-1, -1};
}

/**
 * 寻找目标值的插入位置，当存在重复值时插入到它们后面
 */
public int searchInsert2(int[] nums, int target) {
    int low = 0, high = nums.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        循环不变量：[0, low)：小于等于target的元素，(high, length-1]：大于target的元素
        if (nums[mid] <= target) low = mid + 1;
        else high = mid - 1;
    }
    return low;
}

5. 0～n-1中缺失的数字

题目简述：一个长度为n-1的升序数组中包含了0至n-1中某个数除外的n-1个数，找出这个缺失的数。leetcode链接
思路：二分查找。循环不变量[0, low)为从0到low按序递增的区间，(high, n-1]为从high+1到n按序递增的区间。检查mid然后更新区间。当low越过high时，按照区间定义low索引就是缺失的数字

public int missingNumber(int[] nums) {
    int n = nums.length;
    //定义区间[0, low)和(high, n-1]
    int low = 0, high = n-1;
    while (low <= high) {
        int mid = (low + high) / 2;
        //nums[mid]就等于mid，说明从0到mid是按序递增的，更新low
        if (nums[mid] == mid) low = mid + 1;
        //nums[mid]大于mid，则缺失的数字必在[low,mid)间，从mid到n-1是按序递增的，更新high
        else high = mid - 1;
    }
    return low;
}