标题：【leetcode】二分查找本质

@水墨不写bug

---

正文开始：（点击题目标题转跳到OJ）

目录

（O）前言*

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

思路详解： 

参考代码： 

（二）x的平方根​​​​​​

（三）搜索插入位置

（四）山峰数组的峰顶索引

（五）寻找峰值

（六）寻找旋转排序数组的最小值

（七）点名

---

（O）前言*

        “二分思想”相信看过我的这篇文章《小白鼠试毒——二分法怎么分》的朋友都对其有深刻的理解，具体来说：当我们可以根据一定的标准将元素分为两部分，并根据标准判断哪一部分留下，哪一部分舍去，这时候就可以使用二分。 

        如果我们加上一些限制：考虑题目中给的数组的元素，那么：如果我们可以判断数组具有“二段性”，那么就可以使用二分。 什么是二段性？其实，就是存在一个标准，根据这个标准，我们可以把数组分为“是”和“不是”的两部分，一般这两部分是连续的，这就表明有一个点将数组分为两部分。这就是使用二分的前提条件。

        好消息是二分拥有特定的模板，我们可以根据题目的要求接合对模板的理解来使用模板。最重要的是要理解模板的原理。不然无法正确使用模板。在本文，我会总结出二分的模板，以及如何推导和使用。

        另外，二分的特征时间复杂度是O（logN），换句话说，如果一道题的时间复杂度要求是O（logN），不要忘了试试二分的思路。

---

        二分判断点的选取：

        其实看似是选取二分点，即使是你随便选取一个点作为判断点，二分也是可以进行:如果你选取一个随机点作为二分下标，那么二分的效率可能会受到影响。

        最高效的二分下标选取点是数组的接近中间点的位置。根据概率论中有关数学期望的知识可以给出严格证明，这里我们不再证明。

---

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

给你一个按照非递减顺序排列的整数数组 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]

提示：

• 0 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9
• nums 是一个非递减数组
• -10^9 <= target <= 10^9

题目要求查找两个区间端点的位置，也就是左端点和右端点的位置。分两个步骤依次进行

思路详解： 

第一道题细致讲解，之后的题目只给出重要的部分思路

---

        记查找的值为key。

---

        当我们查找左端点时，根据 “<key” 和 “>=key” 这个标准将区间分为两部分，左边的部分区间都是小于key的，右边的区间都是大于等于key的：

        如果区间中点mid对应的nums[mid] < key,则mid位于左半部分区间，此时更新left下标left = mid +1；（因为左边区间内的值都小于key，可以确定需要查找的目标值一定在右区间中，所以left可以向右移动）

        如果mid对应的nums[mid] >= key，则可以确定mid位于目标值右侧，此时更新查找区域右端点为right = mid；（因为区间右边的值是大于等于key的，可以确定要查找的目标位于左区间内 + mid对应的位置——因为nums[mid]此时等于key，由于无法确定目标值是否在mid位置，如果此时冒然right = mid-1，那么如果mid位置就是目标值的这种情况就被忽略了！）

        当我们查找区间右端点时，根据“<=key” “>key”的二段性将区间分为两部分，左部分的值小于key，右部分的值大于等于key。

        如果区间中点mid对应值nums[mid] <= key 则mid位于则mid在key的左边+mid这个位置，更新left = mid;

        如果区间中点mid对应值nums[mid] > key ,则mid位于key的右边，更新right = right-1；

循环的终止条件：

left < right  

为什么？

对于要查找的数组分三种情况考虑：

        1.有目标值

        

        2.都大于目标值

        3.都小于目标值

在讲解之前，先引入mid的选取规则：

        1.偏左选取——mid = left + (right - left)/2;

        2.偏右选取——mid = left + (right - left + 1)/2;

        他们的区别就是当区间内有偶数个值时，mid选取的是中间偏左的一个还是中间偏右的一个。

        结论：

        在更新区间的时候，无法越过mid的一侧需要选取偏另一侧的mid选取规则。

        为什么？

当区间仅有两个元素的时候，区间端点的选取无非就只有两个情况——偏左的元素或者偏右的元素。在查找区间左端点时，right无法越过mid，正确的mid选取是选取偏左的元素。如果我们这时mid选取偏右的元素，那么由于nums[mid] >= key还是更新 right = mid,这样下去会死循环。

接下来讲解循环终止条件的选择原因：

        对于要查找的数组分三种情况考虑：

        1.有目标值

        left和right都在向目标值靠拢，当left==right时，此时就是目标值，不需要进入循环。

        2.都大于目标值

        right向左移动，当left==right时，此时不需要进入循环，跳出循环判断一下相遇时的值的与目标值的大小就可以了。

        3.都小于目标值

        left向右移动，当left==right时，此时不需要进入循环，跳出循环判断一下相遇时的值的与目标值的大小就可以了。

参考代码： 

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) 
    {
        if(nums.size()==0) return {-1,-1};
        int left = 0,right = nums.size()-1;
        //查找左区间
        int ret_l = -1,ret_r = -1;
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]<target) left = mid+1;
            else right = mid;
        }
        if(nums[left] == target) ret_l = left;
        left = 0,right = nums.size()-1;
        //查找右区间
        while(left<right)
        {
            int mid = left+(right-left+1)/2;
            if(nums[mid]<=target) left = mid;
            else right = mid-1;
        }
        if(nums[right] == target) ret_r = right;
        return {ret_l,ret_r};
    }
};

二分查找模板：

        查找右区间端点：

int left = ..., right = ...;
while (left < right)
{
	int mid = left + (right - left) / 2;
	if (...)
		left = mid + 1;
	else
		right = mid;
}

        查找左区间端点：

int left = ..., right = ...;
while (left < right)
{
	int mid = left + (right - right + 1) / 2;
	if (...)
		left = mid;
	else
		right = mid - 1;
}

        通过观察两个模板，可以发现规律：       

        循环的终止条件相同；

        if条件中有“-1”，mid有“+1”；

有这两个规律就足够了。

---

（二）x的平方根​​​​​​

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

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

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

提示：

• 0 <= x <= 2^31 - 1

         根据题意：

        x < 1 时，根下x小于1，去除小数部分，返回0；

        x > 1 时，1 < 根下x  < x   使用二分，首先要寻找二段性 。

                对于从1开始向后数，每一个数的平方是这样的一组数：

        1   4   9   16   25   36   49   64   81...

        假设x 是26，由于需要将小数部分舍去，得到的结果是5，但是（这里用数学的区间表示）对于[25,36)内的任何一个数，得到的结果都是5，这就相当于一个程序输入[25,36)，输出同一个值，于是这就转化为第一道题查找区间左端点的问题了。

        二段性：

        先不考虑mid的左偏还是右偏，mid是一个大概的区间中点的位置。（对于mid的位置左偏和右偏问题可以通过模板来解决）

        我们首先看二段性：

        根据  mid*mid <= x 或者 mid*mid > x 分类； 

                mid*mid <= x，说明target在mid右侧+mid现在的位置，更新left = mid；

                mid*mid > x ，说明target在target在mid左侧，更新right = mid -1；

        根据模板

        下面有 “-1”，则mid有“+1”：mid = left + (right - left + 1)/2;

        或者由于left无法越过mid，所以要mid向右偏，需要“+1”。

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

---

（三）搜索插入位置

        给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

        请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

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

提示:

• 1 <= nums.length <= 10^4
• -10^4 <= nums[i] <= 10^4
• nums 为 无重复元素 的 升序 排列数组
• -10^4 <= target <= 10^4

二段性：

        数组分为< target  和 >= target 两部分，这就类似于查找区间右端点了。

        需要处理的特殊情况：

        当我们要插入的值在数组的最后时，由于left和right会最终停在最后一个位置上，但是我们要返回的下标是停下的下一个位置，所以需要特殊处理。

参考代码：

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) 
    {
        int left = 0,right = nums.size()-1;
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]>=target) right = mid;
            else left = mid+1;
        }
        if(nums[left] < target) return left+1;//说明插入在最后一个数据后面
        return left;//left的位置即为插入位置
    }
};

什么？你问我为什么不是分为<=  和 >？

        首先，通过测试，将区间分为<= 和 > 是可以 凑巧 通过oj的：

int searchInsert(vector<int>& nums, int target)
{
    int left = 0, right = nums.size() - 1;
    while (left < right)
    {
        int mid = left + (right - left + 1) / 2;
        if (nums[mid] > target) right = mid - 1;
        else left = mid;
    }
    if (nums[left] < target) return left + 1;//说明插入在最后一个数据后面
    return left;//left的位置即为插入位置
}
int searchInsert_(vector<int>& nums, int target)
{
    int left = 0, right = nums.size() - 1;
    while (left < right)
    {
        int mid = left + (right - left) / 2;
        if (nums[mid] >= target) right = mid;
        else left = mid + 1;
    }
    if (nums[left] < target) return left + 1;//说明插入在最后一个数据后面
    return left;//left的位置即为插入位置
}

int main()
{
    vector<int> v = { 1,2,4,5,6 };
    int ret =  searchInsert(v, 3);
    int ret_ =  searchInsert_(v, 3);
    cout << ret << endl;
    cout << ret_ << endl;
	return 0;
}

结果：

2
2

具体为什么，我们分析一下： 

        我们审题，如果target存在，能够找到target，返回target下标即可；（两种分法都是一样的）

        如果target不存在，因为我们在一个位置插入是在当前位置插入，<=  和 >分法  查找的是我们目标插入位置的前一个位置，只不过最后一句对特殊情况的处理发挥了本来它不该发挥的作用，导致结果凑巧正确。（这是不该发生的，是意料之外的情况）

        如果把“<=  和 >分法”的最后的对特殊情况的处理删掉，结果：

1
2

        所以“<=  和 >分法”是错误的。

---

（四）山峰数组的峰顶索引

        符合下列属性的数组 arr 称为 山脉数组 ：

• arr.length >= 3
• 存在 i（0 < i < arr.length - 1）使得：
  • arr[0] < arr[1] < ... arr[i-1] < arr[i]
  • arr[i] > arr[i+1] > ... > arr[arr.length - 1]

        给你由整数组成的山脉数组 arr ，返回满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i 。

        你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。

示例 1：

输入：arr = [0,1,0]
输出：1

示例 2：

输入：arr = [0,2,1,0]
输出：1

示例 3：

输入：arr = [0,10,5,2]
输出：1

提示：

• 3 <= arr.length <= 10^5
• 0 <= arr[i] <= 10^6
• 题目数据保证 arr 是一个山脉数组

 二段性：

        根据arr[mid]    arr[mid +1] 的大小关系 作为二段性判断依据。

class Solution {
public:
    int peakIndexInMountainArray(vector<int>& arr) {
        int left = 1,right = arr.size()-2;
        while(left<right)
        {
            int mid = left +(right-left)/2;
            if(arr[mid] < arr[mid+1]) //在上升段,目标在右侧
                left = mid+1;
            else right = mid;
        }
        return left;
    }
};

---

（五）寻找峰值

        峰值元素是指其值严格大于左右相邻值的元素。

        给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

        你可以假设 nums[-1] = nums[n] = -∞ 。

        你必须实现时间复杂度为 O(log 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。

提示：

• 1 <= nums.length <= 1000
• -2^31 <= nums[i] <= 2^31 - 1
• 对于所有有效的 i 都有 nums[i] != nums[i + 1]

 二段性：

        根据nums[mid]和nums[mid+1]的大小关系为二段性标准。

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left = 0,right = nums.size()-1;
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]<nums[mid+1]) left = mid+1;
            else right = mid;//不存在等于的情况
        }
        return left;
    }
};

---

（六）寻找旋转排序数组的最小值

 

        已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

• 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
• 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

        注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

        给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

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

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

 根据：

        nums[mid]和nums[n-1]大小关系

class Solution {
public:
    int findMin(vector<int>& nums) 
    {
        int n = nums.size(),left = 0,right = n-1;
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]<nums[n-1]) right = mid;
            else left = mid+1;
        }
        return nums[left];
    }
};

---

（七）点名

        某班级 n 位同学的学号为 0 ~ n-1。点名结果记录于升序数组 records。假定仅有一位同学缺席，请返回他的学号。

示例 1:

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

示例 2:

输入: records = [0, 1, 2, 3, 4, 5, 6, 8]
输出: 7

提示：

1 <= records.length <= 10000

 二段性：

        根据是否有偏移来作为二段性依据。

class Solution {
public:
    int takeAttendance(vector<int>& records) 
    {
        
        int left = 0,right = records.size()-1;
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(records[mid]==mid) left = mid+1;
            else right = mid;
        }
        if(records[left]==left) return left+1;
        return left;
    }
};

---

完~

未经作者同意禁止转载