二分查找算法

魑魅魍魉114

已于 2022-05-06 10:11:46 修改

阅读量260

点赞数 2

分类专栏：常见排序算法文章标签：算法数据结构 java

于 2021-02-17 10:08:03 首次发布

原文链接：https://www.cnblogs.com/kyoner/p/11080078.html

版权

常见排序算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

二分查找算法

我周围的人几乎都认为二分查找很简单，但事实真的如此吗？二分查找真的很简单吗？并不简单。看看 Knuth 大佬（发明 KMP 算法的那位）怎么说的：

Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky...

这句话可以这样理解：思路很简单，细节是魔鬼。

本文就来探究几个最常用的二分查找场景：寻找一个数、寻找左侧边界、寻找右侧边界

而且，我们就是要深入细节，比如while循环中的不等号是否应该带等号，mid 是否应该加一等等。分析这些细节的差异以及出现这些差异的原因，保证你能灵活准确地写出正确的二分查找算法。

一、二分查找的框架

public int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;
    while(...){

        int mid = (left + right) / 2;
        if(nums[mid] == target){
            ...;
        }
        else if(nums[mid] < target){
            left = ...;
        }
        else if(nums[mid] > targrt){
            right = ...;
        }
    }
    return ...;

}

分析二分查找的一个技巧是：不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节。本文都会使用 else if，旨在讲清楚，读者理解后可自行简化。

其中...标记的部分，就是可能出现细节问题的地方，当你见到一个二分查找的代码时，首先注意这几个地方。后文用实例分析这些地方能有什么样的变化。

另外声明一下，计算 mid 时需要技巧防止溢出（如果 left 和 right 足够大，mid = (left + right)/2，可能会由于 left+right 导致 int 数据类型越界）建议写成: mid = left + (right - left) / 2，本文暂时忽略这个问题。

二、寻找一个数（基本的二分搜索）

这个场景是最简单的，可能也是大家最熟悉的，即搜索一个数，如果存在，返回其索引，否则返回 -1。

public int binarySearch(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){
            return mid;
        }
        else if(nums[mid] < target){
            left = mid + 1;//注意
        }
        else if(nums[mid] > target){
            right = mid - 1;//注意
        }
    }
    
    return -1;

}

1. 为什么 while 循环的条件中是 <=，而不是 < ？

答：因为初始化 right 的赋值是 nums.length - 1，即最后一个元素的索引，而不是 nums.length。

这二者可能出现在不同功能的二分查找中，区别是：前者相当于两端都闭区间 [left, right]，后者相当于左闭右开区间 [left, right)，因为索引大小为 nums.length 是越界的。

我们这个算法中使用的是 [left, right] 两端都闭的区间。这个区间就是每次进行搜索的区间，我们不妨称为「搜索区间」(search space)。

什么时候应该停止搜索呢？当然，找到了目标值的时候可以终止：

 if(nums[mid] == target)
        return mid;

但如果没找到，就需要 while 循环终止，然后返回 -1。那 while 循环什么时候应该终止？搜索区间为空的时候应该终止，意味着你没得找了，就等于没找到嘛。

while(left <= right)的终止条件是 left == right + 1，写成区间的形式就是 [right + 1, right]，或者带个具体的数字进去 [3, 2]，可见这时候搜索区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。

while(left < right)的终止条件是 left == right，写成区间的形式就是 [right, right]，或者带个具体的数字进去 [2, 2]，这时候搜索区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就可能出现错误。

当然，如果你非要用 while(left < right) 也可以，我们已经知道了出错的原因，就打个补丁好了：

while(left < right) {
    // ...
}
return nums[left] == target ? left : -1;

2. 为什么 left = mid + 1，right = mid - 1？我看有的代码是 right = mid 或者 left = mid，没有这些加加减减，到底怎么回事，怎么判断？

答：这也是二分查找的一个难点，不过只要你能理解前面的内容，就能够很容易判断。

刚才明确了「搜索区间」这个概念，而且本算法的搜索区间是两端都闭的，即 [left, right]。那么当我们发现索引 mid 不是要找的 target 时，如何确定下一步的搜索区间呢？

当然是去搜索 [left, mid - 1] 或者 [mid + 1, right] 对不对？因为 mid 已经搜索过，应该从搜索区间中去除。

3. 此算法有什么缺陷？

答：至此，你应该已经掌握了该算法的所有细节，以及这样处理的原因。但是，这个算法存在局限性。

比如说给你有序数组 nums = [1,2,2,2,3]，target = 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，即索引 3，这样的话此算法是无法处理的。

这样的需求很常见。你也许会说，找到一个 target 索引，然后向左或向右线性搜索不行吗？可以，但是不好，因为这样难以保证二分查找对数级的时间复杂度了。

我们后续的算法就来讨论这两种二分查找的算法。

三、寻找左侧边界的二分搜索

利用二分法寻找左边界是二分查找的一个变体，应用它的题目常常有以下几种特性之一：

数组有序，但包含重复元素
数组部分有序，且不包含重复元素
数组部分有序，且包含重复元素

还可以参考：二分查找左右边界问题、左右边界问题

左侧边界类型1：类型1包括了上面说的第一种，第二种情况。

public int binarySearch(int[] nums, int target){
    if(nums == null || nums.length == 0)
        return -1;
    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;//注意
        }
    }
     // 如果搜索的数字比所有的都大，最终right位置在最后一个元素，left = right+1
    //             比所有的都小，最终left 在0 。所以如果left>=nums.length || nums[left]!=target则未找到
         
    if(left>=nums.length || nums[left]!=target){
        return -1;
    }
    return left;
}

这里也有几个要注意的地方，第一个是关于==的时候数值的更新，对于之前的二分查找，如果==的话，直接return即可，但是这里因为我们需要左边界，所以要向左边逼近，所以这里的赋值只可能是right = mid 或者right = mid-1，因为这样才能向左逼近。但对于right = mid来说可能出现死循环，因为while的条件是<= ,比如当前left = 3， right = 4，那么mid = 3，更新rihgt = 3，然后满足while，并且mid = 3，更新right = 3，发现死循环了，所以只能利用right = mid -1，这样最后跳出循环的时候right的位置是左边界-1，而left可以当作左边界。

左侧边界类型2：

public int search(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) {
                left = mid + 1;
            } else if(nums[mid] == target) {
                right = mid;// 对于left和right相邻时，执行此语句后 left=right，跳出循环
            } else if(nums[mid] > target){
                right = mid; // 循环判断条件为<，所以下一次查找范围为(left,right)即[left,mid-1]

            }
        }

        return nums[left] == target ? left : -1;
}

循环条件： left < right
中间位置计算： mid = left + ((right -left) >> 1)
左边界更新：left = mid + 1
右边界更新： right = mid
返回值： nums[left] == target ? left : -1

与标准的二分查找不同：

首先，这里的右边界的更新是right = mid，因为我们需要在找到目标值后，继续向左寻找左边界。

其次，这里的循环条件是left < right。
因为在最后left与right相邻的时候，mid和left处于相同的位置(前面说过，mid偏左)，则下一步，无论怎样，left, mid, right都将指向同一个位置，如果此时循环的条件是left <= right，则我们需要再进入一遍循环，此时，如果nums[mid] < target还好说，循环正常终止；否则，我们会令right = mid，这样并没有改变left,mid,right的位置，将进入死循环。

事实上，我们只需要遍历到left和right相邻的情况就行了，因为这一轮循环后，无论怎样，left,mid,right都会指向同一个位置，而如果这个位置的值等于目标值，则它就一定是最左侧的目标值；如果不等于目标值，则说明没有找到目标值，这也就是为什么返回值是nums[left] == target ? left : -1。

左边界查找类型3:

public int left_bound(int[] nums ,int target){
    if(nums.length==0){
        return -1;
    }
    int left = 0 ,right = nums.length - 1;
    int mid = 0;
    while(left< right){
        mid = left + (right - left) /2;
        if(nums[mid]>target){
            right = mid - 1;
        }else if(nums[mid]<target){
            left = mid + 1;
        }else{
            right = mid; // 等于的时候说明左边界在[left,mid] 所以right 只能缩小到mid ，而因此外层循环要用<
        }
    }
    // left也是最后的插入位置
    return left;
}

可以看出，这里的while中的判断条件是left < right。而对于==的时候的也变为了right = mid，这是因为当等于的时候其实左边界范围在[left,mid]，所以right应该更新为mid，但是如果这样，之前说过，可能会出现死循环，所以这里的while循环就要对应改为< ,而不能用<=。

左边界查找类型4:

左边界查找的第二种类型用于数组部分有序且包含重复元素的情况，这种条件下在我们向左收缩的时候，不能简单的令 right = mid，因为有重复元素的存在，这会导致我们有可能遗漏掉一部分区域，此时向左收缩只能采用比较保守的方式，代码模板如下：

 public int search(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) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid;
            } else {
                right--;
            }
        }
        return nums[left] == target ? left : -1;
}

它与类型1的唯一区别就在于对右侧值的收缩更加保守。这种收缩方式可以有效地防止我们一下子跳过了目标边界从而导致了搜索区域的遗漏。

四、寻找右侧边界的二分查找：

右边界1：

int right_bound(int[] nums,int target){
    int left = 0,right = nums.length-1,mid = 0;
    while(left<=right){
        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 -1;
        }
    }
    if(right<0 || nums[right]!=target){
        return -1;
    }
    return right;
}

这种方式和二分查找统一，主要注意点就是在等于的时候，因为我们要找右边界，所以将left向右边逼近，同样这里有一个问题是left不能赋值为mid，因为会造成死循环。这样left就相当于在右边界+1的位置，而right相当于右边界。最后同样对right进行一下判断避免越界。

右边界2：

public int right_bound(int[] nums ,int target){
    if(nums.length==0){
        return -1;
    }
    int left = 0 ,right = nums.length - 1;
    int mid = 0;
    while(left< right){
        mid = left + (right - left + 1) /2; // +1 其实是上取整，避免最后left 和right对应值相等且等于target，这样mid还是等于left，然后判断赋值left = mid ，这样就死循环了
        if(nums[mid]>target){
            right = mid - 1;
        }else if(nums[mid]<target){
            left = mid + 1;
        }else{
            left = mid; // 等于的时候说明左边界在[mid,right] 所以left 只能缩小到mid ，而因此外层循环要用<
        }
    }
    return left;
}

这里主要注意的是，mid的计算是向上取整，因为如果和以前一样，那么如果left=3，right =4，且都是target，那么首先mid = 3，然后更新left = 3，发现while死循环，因为我们要找右边界，所以可以将mid计算的时候上取整即可。

五、最后总结

先来梳理一下这些细节差异的因果逻辑：

第一个，最基本的二分查找算法

因为我们初始化 right = nums.length - 1
所以决定了我们的「搜索区间」是 [left, right]
所以决定了 while (left <= right)
同时也决定了 left = mid+1 和 right = mid-1

因为我们只需找到一个 target 的索引即可
所以当 nums[mid] == target 时可以立即返回

第二个，寻找左侧边界的二分查找：

因为我们初始化 right = nums.length
所以决定了我们的「搜索区间」是 [left, right)
所以决定了 while (left < right)
同时也决定了 left = mid+1 和 right = mid

因为我们需找到 target 的最左侧索引
所以当 nums[mid] == target 时不要立即返回
而要收紧右侧边界以锁定左侧边界

第三个，寻找右侧边界的二分查找：

因为我们初始化 right = nums.length
所以决定了我们的「搜索区间」是 [left, right)
所以决定了 while (left < right)
同时也决定了 left = mid+1 和 right = mid

因为我们需找到 target 的最右侧索引
所以当 nums[mid] == target 时不要立即返回
而要收紧左侧边界以锁定右侧边界

又因为收紧左侧边界时必须 left = mid + 1
所以最后无论返回 left 还是 right，必须减一

如果以上内容你都能理解，那么恭喜你，二分查找算法的细节不过如此。

通过本文，你学会了：

1. 分析二分查找代码时，不要出现 else，全部展开成 else if 方便理解。

2. 注意「搜索区间」和 while 的终止条件，如果存在漏掉的元素，记得在最后检查。

3. 如需要搜索左右边界，只要在 nums[mid] == target 时做修改即可。搜索右侧时需要减一。

就算遇到其他的二分查找变形，运用这几点技巧，也能保证你写出正确的代码。LeetCode Explore 中有二分查找的专项练习，其中提供了三种不同的代码模板，现在你再去看看，很容易就知道这几个模板的实现原理了。

魑魅魍魉114

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
二分查找算法

二分查找算法我周围的人几乎都认为二分查找很简单，但事实真的如此吗？二分查找真的很简单吗？并不简单。看看 Knuth 大佬（发明 KMP 算法的那位）怎么说的：Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky...这句话可以这样理解：思路很简单，细节是魔鬼。本文就来探究几个最常用的二分查找场景：寻找一个数、寻找左侧
复制链接

扫一扫