二分查找细究

二分查找细节

二分查找是一种看起来，听起来都很简单的查找算法，但是一旦上升到具体的细节，那么二分查找就开始变得魔鬼了起来。

据说，发明KMP算法的大佬都说二分查找：思路很简单，细节是魔鬼。

我们先看二分查找的基本模板:

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

这套模板有两个地方需要解释，首先是…的部分，这部分内容就是二分查找算法可能坑人的地方，除此之外还需要在意mid的计算过程，我们需要用right-left的结果来计算而不是直接right+left除2来避免溢出

基本二分查找，在不重复的数组中查找单项元素

那么二分查找到底有什么坑人细节呢？先从一道最基本的二分查找开始。

704.二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

这是一道最基本的二分查找题目，我们先直接看代码:

int BinarySearch(vector<int>& nums, int target) {
    int l = 0;
    int mid;
    int r = nums.size() - 1;//注意
    while(l <= r){//注意
        mid = l + (r - l) / 2;//注意
        if (nums[mid] == target){
            return mid;//注意
        }
        else if (nums[mid] > target){
            r = mid - 1;//注意
        }
        else if (nums[mid] < target){
            l = mid + 1;
        }
    }
    return -1;//注意
}

这是最基本的一种二分查找，在一组不重复的数据当中查找某个数是否存在，存在返回下表，不存在返回-1，这段代码是基于闭区间的，有几个地方需要注意:

1. r = nums.size() - 1这句话，表示当前二分查找我们是闭区间的查找形式，即二分查找区间为[left,right]
2. l = mid + 1和r = mid - 1这两句，因为我们是闭区间查找，每次就需要移动到下一个区间的闭区域
3. l <= r这句话，这是因为我们是闭区间上的查找，所以当l == r时我们的查询还没有结束，还需要执行一次[mid,mid]区间上的查找，等式代入一下可得，循环结束条件为nums[mid] == target或区间形式变为[right + 1,right]或[left,left - 1]，这两个区间都为空

基于上面的逻辑，我们可以修改为我们的二分查找代码:

int BinarySearch(vector<int>& nums, int target) {
	int l = 0;
    int mid;
    int r = nums.size();//注意
    while(l < r){//注意
        mid = l + (r - l) / 2;//注意
        if (nums[mid] == target){
            return mid;//注意
        }
        else if (nums[mid] > target){
            r = mid;//注意
        }
        else if (nums[mid] < target){
            l = mid + 1;
        }
    }
    return -1;//注意
}

这样我们就得到了基于**开区间的二分查找写法，即区间为[left,right)**注意这段代码与前面的代码有三个地方的区别:

1. r = nums.size()，因为是开区间所以要右端+ 1
2. l < r类似的，因为是开区间右端+ 1
3. r = mid类似，开区间右端+ 1

二分查找·改，在存在重复元素的数组中查找左侧或右侧边界

上面的二分查找算法，是基于数组中存在不重复元素的，一旦数组中存在了重复元素，这个算法就不适用了，他没办法确定我最终返回的是否是我们需要的元素，比如nums = [1,2,2,2,3]目标值target为2，此时的算法会返回2，虽然从数字上来说没错，可是如果我想返回的最左边的2，那么这个算法显然无法达到目的。

此时，就需要我们对我们的二分查找算法进行修改。

左侧边界的二分查找算法

先上代码:

int LeftBinarySearch(vector<int>& nums,int target){
    if (nums.length() == 0) {
        return -1;
    }
    int left = 0;
    int right = nums.length(); // 注意
    while (left < right) { // 注意
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            right = mid;//注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid; // 注意
        }
    }
    if (left == nums.length()){//注意
        return -1;
	}
    return nums[left] == target ? left : -1;//注意
}

首先，这段代码采用的是左闭右开区间的形式，即[left,right)所以可以看到我们的right初始化为nums.length()，

while的循环结束条件为left < right以及当nums[mid] > target 的时候right要赋值mid

除此之外，左侧边界代码还需要注意以下三个地方:

1. 相等条件的判断，我们不再直接返回mid，而是将区间的右开边界赋值为mid，这样就相当于当前趋于相等的时候我们要压缩区间
2. left值，也就是左侧边界，看起来是数组的下标，实际上除了数组下标外，还有一个含义，因为是左侧边界，所以这个下表还代表着小于target值的数有几个，比如对于数组nums = [2,3,5,7], target = 1，该算法得到的left为0，所以小于target值1的数有0个，因此当我们的left == nums.length()的时候，说明target的值大于整个数组的值，所以说明target的值在数组中不存在，返回-1
3. 除此之外，我们还需要判断当前的这个数是否就是target本身，不等于说明等于target的数在数组织中不存在，返回-1

如果我们要把它修改为闭区间的形式，代码如下:

int LeftBinarySearch(vector<int>& nums,int target){
    int left = 0;
    int right = nums.length() - 1; // 注意
    while (left <= right) { // 注意
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            right = mid - 1;//注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1; // 注意
        }
    }
    if (left >= nums.length() || nums[left] != target){//注意
        return -1;
	}
    return left;//注意
}

可以看到，闭区间的写法除了三个基本的闭区间的调整外，还不需要判断nums为空，并且循环结束的判断也更方便。

这里left >= nums.length()是因为while的结束条件会导致left比right要大一个1，也就是如果target比整个数组中所有的元素都大的话，那么left会等于nums.length()，也就是越界，此时也应该返回-1

右侧边界的二分查找算法

还是先上代码:

int RightBinarySearch(vector<int>& nums,int target){
	if (nums.length() == 0) return -1;
    int left = 0, right = nums.length();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            left = mid + 1; // 注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    if (left == 0){
        return -1;
    }
    return nums[left - 1] == target ? left - 1 : -1; // 注意
}

这段代码依然是左闭右开的形式，类似于左侧边界，修改即可。

另外，需要特别注意，最后的返回不是left而是left - 1，这是因为右侧区间的特殊性，当我们循环结束的时候，这个时候nums[left]一定不等于target了，但是nums[left - 1]却可能与target相等，这是因为我们对left做的更新，总是left = mid + 1.

类似的，当left为0，或者nums[left - 1]不等于target的时候，说明数不存在，返回-1.

下面是闭区间:

int right_bound(vector<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 if (nums[mid] == target) {
            // 这里改成收缩左侧边界即可
            left = mid + 1;
        }
    }
    // 这里改为检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

这里改为right小于0是因为如果target小于所有元素，那么最后会得到-1，我们手动加上这个逻辑防止越界。

参考:二分查找——知乎