力扣题704二分查找详解

小白要躺平

已于 2022-11-22 22:04:42 修改

阅读量355

点赞数 2

文章标签： leetcode 算法 c++

于 2022-11-21 21:03:27 首次发布

本文链接：https://blog.csdn.net/qq_59993282/article/details/127971591

版权

力扣704题目链接

思路：

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，当大家看到题目描述满足如上条件的时候，可要想一想是不是可以用二分法了。二分查找涉及的很多的边界条件，逻辑比较简单，但就是写不好。例如到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？

大家写二分法经常写乱，主要是因为对区间的定义没有想清楚，区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。下面我用这两种区间的定义分别讲解两种不同的二分写法。

二分法第一种写法

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] （这个很重要非常重要）。区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle] 一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

例如在数组：1,2,3,4,7,9,10中查找元素2，如图所示：

代码如下：

// 版本一
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

二分法第二种写法

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。有如下两点：

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

在数组：1,2,3,4,7,9,10中查找元素2，如图所示：（注意和方法一的区别）

代码如下：

// 版本二
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

总结

二分法是非常重要的基础算法，很多时候对于二分法都是一看就会，一写就废？其实主要就是对区间的定义没有理解清楚，在循环中没有始终坚持根据查找区间的定义来做边界处理。区间的定义就是不变量，那么在循环中坚持根据查找区间的定义来做边界处理，就是循环不变量规则。根据两种常见的区间定义，给出了两种二分法的写法，每一个边界为什么这么处理，都根据区间的定义做了详细介绍。

相关力扣题解

class Solution {//35. 搜索插入位置
public:
    int searchInsert(vector<int>& nums, int target) {
	    int left = 0;//二分查找
		int right = nums.size() - 1;
		while (left <= right)
		{
			int mid = (left + right) / 2;//找到中间节点
			if (nums[mid] > target)//目标值小，查找左边
			{
				right = mid - 1;
			}
			else if (nums[mid] < target)//目标值大，查找右边
			{
				left = mid + 1;
			}
			else
			{
				return mid;//找着了返回mid
			}
		}
		return left;//没找着相等值返回left
    }
};

class Solution {//34
public:
    //寻找左边界（包括target元素本身）
    int LeftBorder(vector<int>& nums, int target){
        int left = 0; //上限
        int right = nums.size()-1; //下限
        int leftborder = -1; //初始化左边界值为-1
        while(left<=right){
            int mid = left+((right-left)/2); //中间
            //等于的时候也缩小下限，往目标元素值左边逼近
            if(nums[mid]==target){
                leftborder = mid; //不断更新边界值
                right = mid-1; //接着缩小范围，看看它左边还有没有等于target的元素
            }
            else if(nums[mid]>target){
                right = mid-1;
            }
            else left = mid+1;
        }
        //最后返回左边界的索引
        return leftborder;
    }

    //寻找右边界（包括target元素本身）
    int RightBorder(vector<int>& nums, int target){
        int left = 0; //上限
        int right = nums.size()-1; //下限
        int rightborder = -1; //初始化右边界值为-1
        while(left<=right){
            int mid = left+((right-left)/2); //中间
            //等于的时候也缩小下限，往右边逼近
            if(nums[mid]==target){
                rightborder = mid; //不断更新边界值
                left = mid+1; //接着缩小范围，看看它右边还有没有等于target的元素
            }
            else if(nums[mid]<=target){
                left = mid+1;
            }
            else right = mid-1;
        }
        //最后返回右边界的索引
        return rightborder;
    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int leftborder = LeftBorder(nums, target);
        int rightborder = RightBorder(nums, target);
        //情况1和情况2和情况3
        if(leftborder==-1|| rightborder==-1) return {-1,-1};
        //情况4和5
        else return {leftborder,rightborder};

    }
};

class Solution {//69
public:
    int mySqrt(int x) {
        int l = 0, r = x, ans = -1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if ((long long)mid * mid <= x) {
                ans = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return ans;
    }
};

class Solution {//367. 有效的完全平方数
public:
    bool isPerfectSquare(int num) {
        int left=0;
        int right=num;
        while(left<=right)
        {
            int mid=(right-left)/2+left;
            long long square=(long long)mid*mid;//求得中间数的平方。
            if(square<num)//该数小了在mid右边查找
            {
                left=mid+1;
            }
            else if(square>num)//该数大了需要在mid左边查找
            {
                right=mid-1;
            }
            else{//等于情况返回真
                return true;
            }
        }
        return false;
    }
};