二分查找法细节整理，以及不同场景下的使用模板

目录

一，前言

二，细节整理，不同场景下的使用模板

1.二分查找的框架

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

 1.为什么    while(left <= right)

2.为什么left = mid + 1， right = mid - 1

3.此算法有什么缺陷？

3.寻找左侧边界的二分搜索 

 1.为什么    while(left < right)

2.为什么left = mid + 1， right = mid ？

 4.寻找右侧边界的二分查找

 1.为什么    while(left < right)

2.为什么left = mid + 1， right = mid ？ 

 三，趁热打铁（leetcode 题解：第一个错误的版本）

1.题目描述

2.解题思路 

---

一，前言

相信各位小伙伴在初次接触二分查找算法时很容易理解，很快就上手写代码了，可是代码运行时总是出现各种各样的错误，得不到预期的结果。我听有位大佬说过：“二分查法思想很简单，但细节是魔鬼！” 确实如此，我也为这些细节抓狂过很多次。下面我就针对这些细节进行整理，比如：中值mid 是否应该加一，最左侧索引left，最右侧索引right应该怎么设置，以及结束条件，划分区间区间，以及不同场景下的使用模板。希望能够帮到各位码友。

二分查找的使用前提：要处理的数组必须是有序的。

二分查找场景：寻找一个数、寻找左侧边界、寻找右侧边界。 

二，细节整理，不同场景下的使用模板

1.二分查找的框架

计算 mid 时需要技巧防止溢出，建议写成: mid = left + (right - left) / 2; 这里为了方便大家理解我还是用mid = (right + left) / 2;

话不多说，直接看代码。

int BinarySearch(vectory<int>& nums, int target)
{
    int left = 0, right = ***;
 
    while(***) 
	{
        int mid = (right + left) / 2;
        if (nums[mid] == target) 
		{
            ***
        } 
		else if (nums[mid] < target) 
		{
            left = ***
        } 
		else if (nums[mid] > target)
		{
            right = ***
        }
    }
    return ***;
}

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

二、寻找一个数（基本的二分搜索）
int binarySearch(vectory<int>& nums, int target) 
{
    int left = 0; 
    int right = nums.size() - 1; 
 
    while(left <= right) 
	{ 
        int mid = (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(left <= right)

因为我们规定的是闭区间【left， right】 （right = nums.size() - 1）

2.为什么left = mid + 1， right = mid - 1

 目标区间【left， right】是闭区间，当搜索到nums[mid] 时，如果不满足nums[mid] == target，就去掉nums[mid]，这样区间就被划分为[left, mid - 1] 或者 [mid + 1, right]。

3.此算法有什么缺陷？

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

这样的需求很常见。也许有人会说，找到一个 target 索引，然后向左或向右线性搜索不行吗？
可以，但是不好，因为这样会使算法的时间复杂度大大增加，我们用二分法就是看中它的效率，而不是给自己挖坑。

那该如何解决？

下面我们就要讨论寻找左右两侧边界的二分搜索。

3.寻找左侧边界的二分搜索 

int LeftBound(vector<int>& nums, int target) 
{
    if (nums.size() == 0) return -1;
    int left = 0;
    int right = nums.size(); 
 
    while (left < right) 
	{ 
        int mid = (left + right) / 2;
        if (nums[mid] == target)
		{
            right = mid; //因为我们需找到 target 的最左侧索引,所以当 nums[mid] == target 时不要立即返回,而要收紧右侧边界以锁定左侧边界
        } 
		else if (nums[mid] < target)
		{
            left = mid + 1;
        }
		else if (nums[mid] > target) 
		{
            right = mid; 
        }
    }
    return left;
}

 1.为什么    while(left < right)

因为     int right = nums.size(); 目标区间变成了左闭右开[left, right)。

2.为什么left = mid + 1， right = mid ？

目标区间左闭右开[left, right)，当检查过nums[mid]后就去掉nums[mid]，把区间划分为 [left, mid) 或 [mid + 1, right)。当left == right时跳出while循环，此时返回left或者right结果都一样。

 4.寻找右侧边界的二分查找

int RightBound(vector<int>& nums, int target) 
{
    if (nums.size() == 0) return -1;
    int left = 0;
	right = nums.size();
 
    while (left < right)
	{
        int mid = (left + right) / 2;
        if (nums[mid] == target)
		{
            left = mid + 1; //因为我们需找到 target 的最右侧索引,所以当 nums[mid] == target 时不要立即返回,而要收紧左侧边界以锁定右侧边界。
        } 
		else if (nums[mid] < target) 
		{
            left = mid + 1;
        } 
		else if (nums[mid] > target) 
		{
            right = mid;
        }
    }
    return left - 1;// 注意
}

 1.为什么    while(left < right)

因为     int right = nums.size(); 目标区间变成了左闭右开[left, right)。

2.为什么left = mid + 1， right = mid ？ 

 目标区间左闭右开[left, right)，当检查过nums[mid]后就去掉nums[mid]，把区间划分为 [left, mid) 或 [mid + 1, right)。当left == right时跳出while循环，此时返回left-1或者right-1结果都一样。

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

 三，趁热打铁（leetcode 题解：第一个错误的版本）

1.题目描述

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

2.解题思路 

相比看完上面内容后，大家马上就知道要用二分法寻找左侧边界。

直接看代码

class Solution {
public:
    int firstBadVersion(int n) {
        int left = 1, right = n;

        while (left < right) // 循环直至区间左右端点相同
       { 
            int mid = left + (right - left) / 2; // 防止计算时溢出
            if (isBadVersion(mid))
			{
                right = mid; // 答案在区间 [left, mid) 中
            } 
			else 
			{
                left = mid + 1; // 答案在区间 [mid+1, right) 中
            }
        }
        
        return left; // 此时有 left == right，区间缩为一个点，即为答案
    }
};