原文链接： 点这里
更多内容就在我的个人博客 BlackBlog.tech 欢迎关注！
谢谢大家！

本文源自LeetCode二分查找章节，通过本章节的练习对二分查找的基础知识进行掌握，同时能够利用二分查找解决部分问题。二分查找是一个效率非常高的算法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。掌握二分查找对于提升代码效率很有帮助。
LeetCode二分查找地址：https://leetcode-cn.com/explore/learn/card/binary-search/208/background/832/
本篇文章将介绍3个二分模版，同时完成十个例题。在阅读过程中，如果对三个模板的区别难以理解，请务必完全阅读完，这是一个需要逐步思考的过程。
给个目录：
LeetCode704 二分查找
LeetCode69 x 的平方根
LeetCode374 猜数字大小
LeetCode33 搜索旋转排序数组
LeetCode278 第一个错误的版本
LeetCode75 寻找峰值
LeetCode159 寻找旋转排序数组中的最小值
LeetCode34 在排序数组中查找元素的第一个和最后一个位置
LeetCode658 找到 K 个最接近的元素

二分查找基础知识

什么是二分查找
二分查找是计算机科学中最基本、最有用的算法之一。 它描述了在有序集合中搜索特定值的过程。

二分查找中使用的术语：

目标 Target —— 你要查找的值
索引 Index —— 你要查找的当前位置
左、右指示符 Left，Right —— 我们用来维持查找空间的指标
中间指示符 Mid —— 我们用来应用条件来确定我们应该向左查找还是向右查找的索引

二分查找原理

二分查找是一种在每次比较之后将查找空间一分为二的算法。每次需要查找集合中的索引或元素时，都应该考虑二分查找。如果集合是无序的，我们可以总是在应用二分查找之前先对其进行排序。

二分查找一般由三个主要部分组成：

预处理 —— 如果集合未排序，则进行排序。
二分查找 —— 使用循环或递归在每次比较后将查找空间划分为两半。
后处理 —— 在剩余空间中确定可行的候选者。

二分查找是一个效率非常高的算法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。掌握二分查找对于提升代码效率很有帮助。

复杂度
二分查找的时间复杂度：O(log n)，因为二分查找是通过对查找空间中间的值应用一个条件来操作的，并因此将查找空间折半，在更糟糕的情况下，我们将不得不进行 O(log n) 次比较，其中 n 是集合中元素的数目。
二分查找的空间复杂度：O(1)，不需要任何其他额外空间。

LeetCode704 二分查找

我们先来一道最为基础的二分查找题目，理解一下二分查找。
本题为LeetCode704 二分查找，属于二分查找中最为基础的练习。二分查找，顾名思义，就是将数组一分为二，在左右两边查找，确定元素区间之后再次一分为二，直至确定元素。

题目

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

C++代码

class Solution {
public:
    int search(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) return mid; //如果找到了target，返回当前的索引
            if(nums[mid]<target) left = mid+1; //如果nums[mid]<target，证明正确的值在当前位置的右边
            if(nums[mid]>target) right = mid-1; //如果nums[mid]>target，证明正确的值在当前位置的左边
        }
        return -1;
    }
};

体会

本题是二分查找最为基础的题目，对于理解二分查找非常重要。

二分查找 模版#1

模板 #1 是二分查找的最基础和最基本的形式。这是一个标准的二分查找模板，是非常基础简单的二分查找。模板 #1 用于查找可以通过访问数组中的单个索引来确定的元素或条件。模版#1 不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。

模版#1 对应的例题为：
LeetCode69 x 的平方根
LeetCode374 猜数字大小
LeetCode33 搜索旋转排序数组

模版#1 C++代码

int binarySearch( vector<int> & nums, int target )
{
    if ( nums.size() == 0 )
        return(-1);
    int left = 0, right = nums.size() - 1;
    while ( left <= right )
    {
        /* Prevent (left + right) overflow */
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        else if ( nums[mid] < target ) left = mid + 1;
        else right = mid - 1;
    }
    /* End Condition: left > right */
    return(-1);
}

语法关键

初始条件：left = 0, right = length-1
终止：left > right
向左查找：right = mid-1
向右查找：left = mid+1

LeetCode69 x 的平方根

题目

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

C++代码

class Solution {
public:
    int mySqrt(int x){
        int left = 0;
        int right = x;
        if (x <= 1) return x;
        int ans= 0;
        while(left<=right){
            int mid = (right+left) /2; //计算中间值
            if(x/mid >= mid ) {
                left = mid+1; //如果mid*mid<=x 证明mid小了 left = mid+1
                ans = mid; //当前的mid作为ans
            }
            else right = mid-1; //否则right = mid-1
        }
        return ans;
    }
};

体会

上述代码采用二分查找的思路，与模版完全一致，注意每次计算的过程中要将mid存储在ans中，因为我们无法通过mid*mid==x去判断mid是否是正确值，所以我们将mid存储在ans中，最后返回。

该题还可以使用牛顿迭代法的思路进行求解。
附代码：

class Solution {
public:
    int mySqrt(int x) {
        if (x == 0) return 0;
        double res = 1, pre = 0;
        while (abs(res - pre) > 1e-6) {
            pre = res;
            res = (res + x / res) / 2;
        }
        return int(res);
    }
};

LeetCode374 猜数字大小

题目

我们正在玩一个猜数字游戏。 游戏规则如下：
我从 1 到 n 选择一个数字。 你需要猜我选择了哪个数字。
每次你猜错了，我会告诉你这个数字是大了还是小了。
你调用一个预先定义好的接口 guess(int num)，它会返回 3 个可能的结果（-1，1 或 0）：

-1 : 我的数字比较小
 1 : 我的数字比较大
 0 : 恭喜！你猜对了！

示例 :

输入: n = 10, pick = 6
输出: 6

C++代码

int guess(int num);
class Solution {
public:
    int guessNumber(int n) {
        long left = 0;
        long right = n;
        while(left<=right){
            long mid = (left+right)/2;
            if(guess(mid)==0) return mid;
            if(guess(mid)==1) left = mid+1;
            if(guess(mid)==-1) right = mid-1;
        }
        return left;
    }
};

体会

这个题完全就是大一的课后题，基础二分查找问题，与模版#1思路完全一致，比较大小的部分已经在guess中封装了，注意判断好guess最后的返回值。

LeetCode33 搜索旋转排序数组

题目

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

C++代码

class Solution {
public:
    int search(vector<int> nums, int target) {
        //对于特殊情况的判断
        if(nums.size()==0) return -1;
        if(nums.size()==1 && nums[0]==target) return 0;
        if(nums.size()==1 && nums[0]!=target) return -1;

        int index= 0 ; //记录轴点
        int size = nums.size();//记录下初始数组的长度
        for(int i=0;i<nums.size();i++){
            if(nums[i]<nums[i-1]){
                index = i; //找到轴点后结束循环
                break;
            }
            nums.push_back(nums[i]); //在找到轴点之前，将轴点前数字依次放在数组尾部
        }
        int left = index; //left = 轴点
        int right = nums.size()-1; //right = 数组当前长度-1 
        int ans = -1;//ans表示最终的位置
        while(left<=right){
            int mid = (left+right)/2; //计算中点
            if(nums[mid]==target){
                ans = mid; //如果nums[mid] == target 
                break;
            }
            if(nums[mid]<target) left = mid+1; //如果nums[mid]<target 修改left
            if(nums[mid]>target) right = mid-1; //如果 nums[mid]>target 修改 right
            if(nums[right] == target ) ans = right; //如果 nums[right] == target 将 ans修改为right 否则ans为-1
            else ans = -1;
        }
        return ans % size;
    }
};

体会

依旧是一个模版题，难度较低。我们之前说过，二分查找的三个步骤，第一步是预处理 即如果集合未排序，则进行排序。这个题将数组对某一轴点进行了旋转，需要进行预处理。我们寻找到轴点，将数组修改为升序后，预处理完成，后续进行二分即可。该题最后的处理有些类似模板2。

二分查找 模版#2

模板 #2 是二分查找的高级模板。它用于查找需要访问数组中当前索引及其直接右邻居索引的元素或条件。
查找条件需要访问元素的直接右邻居。
使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。
保证查找空间在每一步中至少有 2 个元素。
需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。

模版#2 对应的例题为：
LeetCode278 第一个错误的版本
LeetCode75 寻找峰值
LeetCode159 寻找旋转排序数组中的最小值

模版#2 C++代码

int binarySearch(vector<int>& nums, int target){
   if(nums.size() == 0)
       return -1;

   int left = 0, right = nums.size();
   while(left < right){
       // Prevent (left + right) overflow
       int mid = left + (right - left) / 2;
       if(nums[mid] == target){ return mid; }
       else if(nums[mid] < target) { left = mid + 1; }
       else { right = mid; }
   }

   // Post-processing:
   // End Condition: left == right
   if(left != nums.size() && nums[left] == target) return left;
   return -1;
}

语法关键

初始条件：left = 0, right = length
终止：left == right
向左查找：right = mid
向右查找：left = mid+1

LeetCode278 第一个错误的版本

题目

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

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

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

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。 

C++代码

class Solution {
public:
    int firstBadVersion(int n) {
        long left = 0;
        long right = n;
        while(left<right){
            long mid = (left+right)/2; //计算中点
            if(isBadVersion(mid)==false) left = mid+1; //如果mid是正常产品，证明第一个错误产品在右侧
            if(isBadVersion(mid)==true) right = mid; //如果mid是错误产品，证明第一个错误产品在是自己或者在左侧
        }
        return left;
    }
};

体会

题目非常简单，直接套用模板#2即可。此题与模板#1的最大区别就在于，right不能修改为mid-1，而必须修改为mid。因为当如果mid是错误产品，无法判断第一个错误版本在mid之前，还是就是当前mid。这是模板#2与模板#1的最大不同。

LeetCode75 寻找峰值

题目

峰值元素是指其值大于左右相邻值的元素。
给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。
数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞。

示例 1:

输入: nums = [1,2,3,1]
输出: 2
解释: 3 是峰值元素，你的函数应该返回其索引 2。

示例 2:

输入: nums = [1,2,1,3,5,6,4]
输出: 1 或 5 
解释: 你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

说明:
你的解法应该是 O(logN) 时间复杂度的。

C++代码

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        if(nums.size()==1) return 0;
        long left = 0;
        long right = nums.size()-1;
        while(left<right){
            long mid = (left+right)/2; //计算中间值
            if(nums[mid]>nums[mid+1]) right = mid; //如果当前值大于后一个值 证明当前点可能是峰值点
            if(nums[mid]<nums[mid+1]) left = mid+1; //如果当前值小于后一个值 证明在这之后没有峰值点
        }
        return left;
    }
};

体会

直接套用模板2，此题与上一道题非常类似，如果当前值大于后一个值 证明当前点可能是峰值点 right修改为mid，如果当前值小于后一个值 证明在这之后没有峰值点left修改为mid+1，最后返回left。
PS：如果此题要求求解最值，则需要使用三分法。

LeetCode159 寻找旋转排序数组中的最小值

题目

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
示例 1:

输入: [3,4,5,1,2]
输出: 1

示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

C++代码

class Solution {
public:
    int findMin(vector<int> nums) {
        if(nums.size()==1) return nums[0];
        int left = 0;
        int right = nums.size()-1;
        while(left<right && nums[left]>nums[right] ){
            int mid = (left+right)/2;
            if(nums[left]<=nums[mid]) left = mid+1; //如果nums[left]<=nums[mid]，即mid前的序列是递增的，则轴值一定不在mid之前，修改left=mid+1
            else if(nums[left]>nums[mid]) right = mid;//如果nums[left]>nums[mid]，mid前的序列不是递增的，则可能存在轴值，切mid有可能是轴值，修改right=mid。
        }
        return nums[left];
    }
};

体会

依旧是一道模版题。在确定mid之后，需要比对left与mid之间的关系，如果nums[left]<=nums[mid]，即mid前的序列是递增的，则轴值一定不在mid之前，修改left=mid+1；如果nums[left]>nums[mid]，mid前的序列不是递增的，则可能存在轴值，切mid有可能是轴值，修改right=mid。注意确定好边界即可。

二分查找 模版#3

模板 #3 是二分查找的另一种独特形式。它用于搜索需要访问当前索引及其在数组中的直接左右邻居索引的元素或条件。
搜索条件需要访问元素的直接左右邻居。
使用元素的邻居来确定它是向右还是向左。
保证查找空间在每个步骤中至少有 3 个元素。
需要进行后处理。 当剩下 2 个元素时，循环 / 递归结束。 需要评估其余元素是否符合条件。

模版#3 对应的例题为：
LeetCode34 在排序数组中查找元素的第一个和最后一个位置
LeetCode658 找到 K 个最接近的元素

模版#3 C++代码

int binarySearch(vector<int>& nums, int target){
    if (nums.size() == 0)
        return -1;

    int left = 0, right = nums.size() - 1;
    while (left + 1 < right){
        // Prevent (left + right) overflow
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid;
        } else {
            right = mid;
        }
    }
    // Post-processing:
    // End Condition: left + 1 == right
    if(nums[left] == target) return left;
    if(nums[right] == target) return right;
    return -1;
}

语法关键

初始条件：left = 0, right = length-1
终止：left + 1 == right
向左查找：right = mid
向右查找：left = mid

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

题目

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

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

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

C++代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.size()==0) return {-1,-1};
        int left = 0;
        int right = nums.size()-1;
        while(left<right){
            int mid = (left+right)/2;
            if(nums[mid]==target) { //如果找到target 只需要向前向后搜索这个序列 找到起点和终点即可
                int I=mid;
                int j=mid;
                while(nums[i+1]==target && i<nums.size()-1) i=i+1; 
                while(nums[j-1]==target && j>0) j = j-1;
                return{j,i};
            }
            if(nums[mid]<target) left = mid+1; //如果nums[mid]<target 说明target在mid的右侧
            else if(nums[mid]>target) right = mid-1; //如果nums[mid]>target 说明target在mid的左侧
        }
        return{-1,-1};
    }
};

体会

做这个题的时候很想将模版#3套用进去，但是没有成功。这个题使用的是比较经典的二分思路。本次需要寻找对应序列的起点与终点，所以当我们找到一个target的值时，要向前向后进行搜索确定序列的起点终点。

LeetCode658 找到 K 个最接近的元素

题目

给定一个排序好的数组，两个整数 k 和 x，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。如果有两个数与 x 的差值一样，优先选择数值较小的那个数。
示例 1:

输入: [1,2,3,4,5], k=4, x=3
输出: [1,2,3,4]

示例 2:

输入: [1,2,3,4,5], k=4, x=-1
输出: [1,2,3,4]

说明:
k 的值为正数，且总是小于给定排序数组的长度。
数组不为空，且长度不超过 104
数组里的每个元素与 x 的绝对值不超过 104

C++代码

class Solution {
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int left =0;
        int right = arr.size()-k; //为了防止越界，将right定为arr.size()-k，做预处理。
        while(left<right){
            int mid = (left+right)/2;
            if(abs(arr[mid]-x)<=abs(arr[mid+k]-x)){ //比较arr[mid]与x的差值 与 arr[mid+k]与x的差值，如果abs(arr[mid]-x)<=abs(arr[mid+k]-x)，证明左侧离x更接近，否则右侧与x更接近。
                right = mid;
            }
            else left = mid+1;
        }
        return vector<int>(arr.begin()+left, arr.begin() + left+k); //返回结果的时候同样要做处理。
    }
};

体会

本题依旧没有用到模版#3（尴尬！），采用类似模版#2的思路，但本题的特殊之处在于预处理和后处理。预处理为了防止越界，将将right定为arr.size()-k，返回结果时返回的事[left,left+k]这一段序列。
本题使用二分的思路，我们要找与x最接近的k个数，每次计算出mid后，比较arr[mid]与x的差值 与 arr[mid+k]与x的差值，如果abs(arr[mid]-x)<=abs(arr[mid+k]-x)，证明左侧离x更接近，更新right；否则右侧与x更接近，更新left。

总结

模版对比

（图片源自LeetCode）
三个模版的主要差异在于左、中、右索引的分配，循环或递归终止条件，后处理。
二分查找是非常常用的算法，真实应用中，我们并不需要死记硬背这三个模版，更重要的是通过这三个模版理解二分搜索，在实际应用中，仔细确定查找边界、递归范围，一般便可以解决问题。