二分查找算法基础及进阶详解上边界与下边界_二分查找的上界下界是什么意思-CSDN博客

本文链接：https://blog.csdn.net/weixin_58428691/article/details/128016202

本文介绍了二分查找算法的基础概念，强调了排序在查找中的重要性，并通过实例展示了非递归和递归两种实现方式。进阶篇探讨了如何在找到目标元素时获取其出现的区间，并提醒了在实现过程中避免死循环的注意事项。最后，从数学角度分析了二分查找的时间复杂度，指出其高效性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一. 基础篇

首先明确，二分查找算法应用的前提是数组已经排序完成。排序的重要意义之一，就是为检索带来方便。试想有 $10^{6}$ 个整数，希望确认其中是否包含 12345，最容易想到的方法是把他们放到数组里面，然后一次检查这些整数是否等于12345。这样的方式对于 “单次询问” 来说运行的很好，也很简单，但如果需要找10000个数，就需要把整个数组遍历10000次。而如果先将数组排序，就可以查找的更快——好比在字典中找单词不必一页一页翻一样。

在有序表中查找元素常常使用二分查找法（Binary Search），有时也译为 “折半查找” ，基本思路就像是 “猜数字游戏” ：你在心里想一个不超过1000的正整数，我可以保证在10次之内猜到它——只要你每次告诉我猜的数比你想的大一些、小一些，或者正好猜中。

猜的方法就是 “二分”。首先我才猜500，除了运气特别好正好猜中以外，不管你说 “太大” 还是 “太小” ，我都能把可行范围缩小一半：如果 “太大” ，那么答案在1~499之间；如果 “太小”，那么答案在501~1000之间。只要每次选择区间的中点去猜，每次都可以把范围缩小一般。由于

$log_{2}1000<10$ ,10次一定能猜到.

这也是二分查找的基本思路。

在算法竞赛中一般用非递归的写法：

public class Main{
    public static void main(String[] args) throws IOException {
        int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int target = 7;
        int left = 0, right = nums.length, mid = 0;
        while(left <= right) {
            mid = (left + right) / 2;
            if(nums[mid] == target) break;
            else if(nums[mid] > target) right = mid - 1;
            else left = mid + 1;
        }
        System.out.println(nums[mid]);
    }
}

当然，还有活在课本里的递归写法：

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

二. 进阶篇

如果数组中有多个元素都是target，上面的函数返回的是哪一个的下标呢？第一个？最后一个？。不难看出，如果所有元素都是要找的，它返回的是中间那一个。有时，这样的结果并不是很理想，能不能求出值等于target的完整区间呢（由于已经排好序，相等的值会在一起）？

下面的程序，当target存在时返回它出现的第一个位置（左闭右开）。如果不存在，返回这样一个下标i：在此处插入target后序列依然有序。

public static int binarySearch(int[] a,int left,int right, int target) {
        int mid=0;
        while(left<right){
            mid = (left + right) / 2;
            if(a[mid] >= target) right = mid;
            else left = mid + 1;
        }
        return left;
    }

类似地，可以写一个upperBound程序，当target存在时返回它出现的最后一个位置的下一个位置（左闭右开）（因为要求最后一个位置的下一个位置，所以最开始的right赋值为数组最右索引+1）。如果不存在，返回这样一个下标i：在此处插入target后序列任然有序。

public static int binarySearch(int[] a,int left,int right, int target) {
        int mid=0;
        while(left<right){
            mid = (left + right) / 2;
            if(a[mid] <= target) left = mid + 1;
            else right = mid;
        }
        return left;
    }

！！！注意这里有个非常要注意的地方，mid = (left + right) / 2;这个地方，计算的时候由于会舍弃小数点后面部分（例如(1+2)/2 => 1 ,(1+3)/2 => 2)，容易造成死循环bug，假如上面这个程序这么写:

当target存在时返回它出现的位置。

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

给出数组[1,3]，target=2，那么这个程序会死循环，因为mid永远指向1，而target是2，永远都left=mid！！！这里留给读者自己思考（提示，求解上边界或者下边界的时候，最好都写成left=mid+1，right=mid。不要写成left=mid，right=mid-1）。

三. 数学推理

最后用数学的角度求出二分查找的时间复杂度:

$T\left ( n \right )=T\left ( \frac{n}{2} \right )+c =T\left ( \frac{n}{2} \right )+c+c =T\left ( \frac{n}{2^{k}} \right )+kc=T\left ( 1 \right )+clogn=O(logn)$

忽略常量和非主导项，二分查找算法的时间复杂度为 $O(logn)$ 。具有 $O(logn)$ 时间复杂度的算法称为对数算法，体现了对数级的增长率。log的底为2，但是底不会影响对数的增长率，因此可以将其忽略。随着时间规模的增长，对数算法复杂度增长的比较缓慢。在二分查找的示例中，将数组的大小翻倍，最多增加一次的比较。如果输入规模平方，那么算法的时间复杂度只会加倍。因此，对数-时间算法是很高效的。