【数据结构与算法】二分法的边界问题总结

参考链接：代码随想录

二分查找涉及的很多的边界条件，逻辑比较简单，但就是写不好。例如到底是 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;
    }
};

总结：

两种区间，两点注意
1、定义 target 是在一个在左闭右闭的区间里，也就是[left, right]时，
while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
2、定义 target 是在一个在左闭右开的区间里，也就是[left, right）时，
while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]，只是比较到nums[middle - 1]而已，如果此时的right更新为middle - 1，那么会只比较到middle - 2，少了一个位置
画图看分界点，以及nums[mid]与target满足特定关系时，边界到底该不该，能不能取到，由此来判断边界写法。

（2022/3/9）

根据y总的图，自己画的图
至此为止，对二分法的认识：
要注意两个地方：
1、查找的范围，是左闭右闭还是左闭右开，这个影响到while的条件写法，也影响到l和r的更新语句写法。
2、要找的那个点，你是用左区间满足条件来写，还是用右区间满足条件来写。这个也关系到l和r的更新语句（其实就是精确定位经过一次二分后的最小有效区间的问题）
至于mid = (l + r + 1) >> 2这里是不是要加1，就看l的更新语句是不是l = mid，如果是就要加1，因为l与r相差1的时候，mid = (l + r) >> 2向下取整，l更新完还是原来的l，就是为了防止这个死循环问题。
2022/3/20

剑指 Offer 11. 旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为1。  

示例 1：

输入：[3,4,5,1,2]
输出：1
示例 2：

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

[参考答案(自己写的哈哈哈)](https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/solution/by-shi-you-xin-sheng-avl5/)

1、暴力（回去等感谢信吧~）
class Solution {
public:
    int minArray(vector<int>& numbers) {
        int min = numbers[0];
        for(int i = 0;i < numbers.size();i++)
        {
            if(numbers[i] < min) min = numbers[i];
        }
        return min;
    }
};
遍历n次，时间复杂度O(n)

2、双指针算法
class Solution {
public:
    int minArray(vector<int>& numbers) {
        int i = 0,j = numbers.size() - 1,prel = numbers[0],prer = numbers[j];
        while(i < j)
        {
            if(numbers[i] < numbers[j]) return numbers[i];
            else
            {
                prel = numbers[i];
                prer = numbers[j];
                i++,j--;
                if(prel > numbers[i])
                {
                    return numbers[i];
                }
                else if(prer < numbers[j])
                {
                    return prer;
                }
            }
        }
        return numbers[0];
    }
};
遍历n/2次，时间复杂度O(n)

3、二分法
class Solution {
public:
    int minArray(vector<int>& numbers) {
        int l = 0,r = numbers.size() - 1;
        if(numbers[l] < numbers[r]) return numbers[l];
        while(l < r)
        {
            if(numbers[l] < numbers[r]) return numbers[l];
            int mid = l + (r - l) / 2;
            if(numbers[mid] < numbers[r])
            {
                r = mid;
            }
            else if(numbers[mid] > numbers[r])
            {
                l = mid + 1;
            }
            else
            {
                l++;
            }
        }
        return numbers[l];
    }
};
除极端情况，平均遍历logn次，但时间复杂度只能是O(n)

总结：极端情况，如[10,1,10,10,10,10,10,10,10,10,10,10,10,10]这种，二分法要遍历n次，但是正常一点的可以认为是O(logn)
所以，给测试集的家伙，
不当人，第二种双指针最优
当人，二分法最优

结合这个题，加一点对二分法的总结：
1、各种极端情况，分清楚，各采用各处理方法，不要混淆
2、谨慎收缩搜索区间

2022/4/10再总结
取的r值决定了代码咋写
第一种写法
r = nums.size() - 1，实实在在的能取到的下标，就是左闭右闭，那么while判断的时候应该写while(l <= r) 改动l 和r 值的时候就底气硬一些，
l = mid + 1,r = mid - 1，反正l和r我都能实打实的取到，mid既然不等于target那我留这个位置干嘛？
第二种写法
r = nums.size() ，右边界不能实实在在的取到，就是左闭右开，那么while判断的时候应该写while(l < r) 改动l 值的时候就底气硬一些（毕竟l能取到），改动r 值的时候就底气软一些（毕竟r不能取到），
l = mid + 1,r = mid，反正l能实打实的取到，mid既然不等于target那我留这个位置干嘛？但是r不能实打实的取到，所以r = mid不会带入冗余元素。