基础算法合集-二分查找(三种写法)

一只鱼^_

墨衍会员 · AI 创作全网分发码龄3年

关注

原创 2025-04-24 09:08:57 675 阅读 AI 写同款· GEO 优化 ›

详解二分查找的两种写法以及二分查找的六种变形本文详解了二分查找的两种写法以及二分查找的六种变形。阅读详情

数组如下:

[5,7,7,8,8,10]

问题：

返回有序数组中第一个>=8的数的位置,如果所有数都<8,返回数组长度

暴力做法:

遍历每个数, 询问它是否>=8 ？显然时间复杂度是O(n)

高效做法:

L和R分别指向询问的左右边界，即闭区间[L,R]，M指向当前正在询问的数 (L=0, R=n-1)

5 7 7 8 8 10
L   M      R

观察上图我们很容易得出以下两个结论:

如果当前数是小于8, 由于数组是有序的, 那么当前数和当前数左边的所有数, 都是<8的
如果当前数是大于等于8, 由于数组是有序的, 那么当前数和当前数右边的所有数, 都是>=8的

如果当前数组长度是偶数的话,中间那个数的下标为(L+R)/2,
由于C++/JAVA中"/"是下取整的,所以此时的中位数是中间靠左的那个数
如果当前数组长度是奇数的话,中间那个数的下标为(L+R)/2,此时就是正中间的那个数

第二次查询->将L更新为M+1的位置

5 7 7 8 8 10
      L M  R
对于为啥不能将L更新为M?
这是因为我们每时每刻都是在闭区间上进行处理的,如果把L改成M,那就是左开右闭区间了.
当数组中只有一个元素时,
 8
L,R
你把R更新成M，那不就死循环了吗
因为arr[4]=8>=8,所以继续执行第三次查询

第三次查询->将R更新M-1

5 7 7 8 8 10
      LR
arr((L+R)/2)>=8

第三次查询->将R更新M-1

5 7 7 8 8 10
    R L
其实我们不难看出,在循环过程中,L左侧的数都是<8的,R右侧的数都是>=8的
循环不变量: L-1始终是<8,R+1始终是>=8
所以在循环结束时，R+1是我们要找的答案,由于循环结束后R+1=L,所以答案也可以用L表示

题目：在排序数组中查找元素的第一个和最后一个位置

原题链接：34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

题目描述：给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8

输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6

输出：[-1,-1]

示例 3：

输入：nums = [], target = 0

输出：[-1,-1]

按上述的思路实现(闭区间)
int lower_bound(vector<int>& nums,int target){
    int left=0; int right=nums.size()-1;
    while(left<=right){
        int mid=left+(right-left)/2;
        if(nums[mid]<target){
            left=mid+1;
        }else{
            right=mid-1;
        } 
    }
    return right+1; //return left
}

左闭右开区间的写法
5 7 7 8 8 10
L            R
此时右边界初始为6
此时上述的第三次查询,更新R=M-1时,就可以修改成R=M了
5 7 7 8 8 10
      LR
此时循环的截止条件就变为left<right,同时left==right时截止
int lower_bound2(vector<int>&nums,int target){
    int left=0; int right=nums.size();
    while(left<right){
        int mid=left+(right-left)/2;
        if(nums[mid]<target){
            left=mid+1;   //[mid+1,right]
        }else{
            right=mid;    //[left,mid)
        }
    }
    return left;  //循环结束时,left==right
}

开区间的写法
  5 7 7 8 8 10
 L            R
L和R分别初始化为-1和6
 5 7 7 8 8 10
L    M       R
第一次查询后,L更新为M
 5 7 7 8 8 10
L    M   M1   R
第二次查询后,R更新到M1
同时最后终止条件就变成了
5 7 7 8 8 10
    L R   
此时(L,R)内就没有任何元素了
所以最后R就是指向答案的
终止条件的话,L+1=R
//开区间的写法
int lower_bound3(vector<int> &nums, int target) {
    int left = -1, right = nums.size(); // 开区间 (left, right)
    while (left + 1 < right) { // 区间不为空
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid; // 范围缩小到 (mid, right)
        } else {
            right = mid; // 范围缩小到 (left, mid)
        }
        // 也可以这样写
        // (nums[mid] < target ? left : right) = mid;
    }
    return right;
}

补充: 原问题是返回有序数组中第一个>=8的数的位置,如果问题改成>8/<8/<=8,那该如何解决呢?
">" 可以看成找>=8+1=9 的情况
"<" 可以看成找>=8左边那个数 的情况 => 找到>=8的索引然后减1
"<=" 可以看成找>8左边那个数 的情况 => 找到>8的索引然后减1
以上就是所有在有序数组中进行二分查找的情况

最后我们来解决上述题目

class Solution {
public:
    //闭区间的写法
    int lower_bound(vector<int>& nums,int target){
        int left=0; int right=nums.size()-1;
        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            } 
        }
        return right+1;
    }
    //开区间的写法
    int lower_bound3(vector<int> &nums, int target) {
        int left = -1, right = nums.size(); // 开区间 (left, right)
        while (left + 1 < right) { // 区间不为空
            // 循环不变量：
            // nums[left] < target
            // nums[right] >= target
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid; // 范围缩小到 (mid, right)
            } else {
                right = mid; // 范围缩小到 (left, mid)
            }
            // 也可以这样写
            // (nums[mid] < target ? left : right) = mid;
        }
        return right;
    }
    //[A,B) 区间的写法
    int lower_bound2(vector<int>&nums,int target){
        int left=0; int right=nums.size();
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]<target){
                left=mid+1;   //[mid+1,right]
            }else{
                right=mid;    //[left,mid)
            }
        }
        return left;  //循环结束时,left==right
    }
        vector<int> searchRange(vector<int>& nums, int target) {
        int start=lower_bound(nums,target);
        if(start==nums.size()||nums[start]!=target){
            return {-1,-1};     //nums数组中没有target
        }
        //如果start 存在,那么end必定存在
        int end=lower_bound(nums,target+1)-1;
        return {start,end};
    }
};
start=nums.size()是left不断向右进行移动,当L=R+1,L>R终止,R其实是一直都没有移动
例子如下:
1 2 3 4 5 6 7 找>=8的数
start返回的是>=target的位置,end返回的是<=target+1的位置
根据上面提到的,<=target的情况,可以转换成找>=target+1,即lower_bound(nums,target+1), 最后再-1,就为lower_bound(nums,target+1)-1

时间复杂度的计算