二分法算法模板

最新推荐文章于 2024-08-21 21:50:12 发布

You...Y

最新推荐文章于 2024-08-21 21:50:12 发布

阅读量407

点赞数 2

分类专栏：算法 C++

本文链接：https://blog.csdn.net/weixin_42477773/article/details/108270463

版权

C++ 同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

算法

3 篇文章 1 订阅

订阅专栏

参考：https://labuladong.gitbook.io/algo/labuladong-he-ta-de-peng-you-men
非常感谢上述链接作者，受益良多

文章目录

二分查找框架：
二分查找关键点：
习题
- 1、二分查找（lt 704）
寻找左侧边界的二分搜索框架：
寻找右侧边界的二分搜索框架

二分查找框架：

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1; // 注意

    while(left <= right) {
        int mid = left + (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）int left = 0, right = nums.length() - 1 / nums.length
对于右值right的初始化存在两种情形：nums.length() - 1和nums.length()，这二者的区别在于前者相当于两端都闭区间[left,right]，后者相当于左闭右开区间[left,right)，因为索引 nums.length是越界的。
2）while中的停止条件while(left <= right)或while(left < right).
while(left <= right)的终止条件是left == right + 1，写成区间形式就是[right + 1,right]，或者带个具体的数字进去 [3, 2]，可见这时候区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。
while(left < right)的终止条件是left == right，写成区间形式就是[left,right]，或者带个具体的数字进去 [2, 2]，这时候区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就是错误的。因此在查找精确值target时，需要打个补丁在最后判断一下nums[left] == target ? left : -1。
3）while循环中left和right的更新
此处与第二步中介绍的搜索区间有关。
当右值初始为nums.length() - 1时，搜索区间为两端都闭区间[left,right]，那么当发现索引mid不是要找的target时，下一步应该去搜索区间[left,mid - 1]或[mid + 1,right]，即right = mid - 1或left = mid + 1,因为mid已经被搜索过了。
当终止条件为nums.length()时，搜索区间为左闭右开区间[left,right)，那么当索引mid不是要找的target时，下一步应该去搜索区间[left,mid)或[mid + 1,right),即right = mid或left = mid + 1，同样是因为mid已经被搜索过了。注意此时while循环终止条件为while(left < right)，因为如果为while(left <= right)时，最后搜索区间为[right + 1,right)，但实际mid取不到right，陷入死循环。
最基本的二分查找算法为：
1、初始化 right = nums.length - 1
2、决定了我们的「搜索区间」是 [left, right]
3、决定了 while (left <= right)终止条件为left == right + 1
4、决定了 left = mid+1 和 right = mid-1
因为我们只需找到一个 target 的索引即可
所以当 nums[mid] == target 时可以立即返回

习题

1、二分查找（lt 704）

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        if (len == 0) return -1;
        int left = 0,right = len - 1; // 搜索区间[left,right]
        while (left < right) { // 结束条件：left == right，会漏掉最后一个区间
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) 
                return mid;
            else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        // 补充最后一个区间
        return nums[left] == target ? left : -1;
    }
};

此算法的缺陷：
给你有序数组 nums = [1,2,2,2,3]，target 为 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，即索引 3，这样的话此算法是无法处理的。
这样的需求很常见，你也许会说，找到一个 target，然后向左或向右线性搜索不行吗？可以，但是不好，因为这样难以保证二分查找对数级的复杂度了。
我们后续的算法就来讨论这两种二分查找的算法。

寻找左侧边界的二分搜索框架：

int left_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0;
    int right = nums.length(); // 注意

    while (left < right) { // 注意
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            right = mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid; // 注意，不断收缩右边界
        }
    }
    return left;
}

1、此处while中采用while(left < right)是由于right初始值为nums.length()，决定了搜索区间为左闭右开[left,right)
2、while循环中left和right的更新是由于，我们的搜索区间为[left,right)，所以当nums[mid]被检测后，下一步的搜索区间去掉mid分割成两个区间[left,mid)和[mid + 1,right)
3、为什么该算法能搜索做左侧边界？关键在于nums[mid] == target的处理

	 if (nums[mid] == target) {
	            right = mid;

可见，找到target时没有立即返回，而是继续缩小搜索区间的上界right，在区间[left,mid)中继续搜索，即不断地向左收缩，达到锁定左侧边界的目的。
4、最后返回left而不是right?其实两者是相同的，因为while终止条件是left == right

上述right的初值为nums.length()，我们再看看初值为nums.length() - 1的情形。
1、right = nums.length() - 1，搜索区间为[left,right]，决定了while结束条件为(left <= right)，终止条件为(right + 1 == right)
2、因为搜索区间是两端都闭的，且现在搜索的是左侧边界，那么left和right的更新逻辑为：

if(nums[mid] < target) {
        left = mid + 1;
} else if (nums[mid > target]) {
        right = mid - 1;
} else if (numd[mid] == target) {
        // 收缩右侧边界
        right = mid - 1; 
}

由于while的终止条件为left == right + 1，所以当target比所有元素都大时，会存在越界的情况，因此在最后返回结果时应该检查越界情况：

if (left >= nums.length || nums[left] != target)
    return -1;
return left;

因此，完整代码为：

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    // 搜索区间为 [left, right]
    while (left <= right) { //终止条件：left == right + 1
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        } else if (nums[mid] > target) {
            // 搜索区间变为 [left, mid-1]
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 收缩右侧边界
            right = mid - 1;
        }
    }
    // 检查出界情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}

寻找右侧边界的二分搜索框架

int right_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;

    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            left = mid + 1; // 注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    return left - 1; // 注意
}

1、为什么该算法能找到右侧边界，关键点在于:

if (nums[mid] == target) {
    left = mid + 1;

当nums[mid] == target时，此时不要立即返回，由于是搜索右边界，所以增大搜索区间的下界left，使得区间不断向右收缩，达到锁定右侧边界的目的。
2、为什么最后返回left - 1
由于while循环的结束条件是left == right，因此，left和right是一样的。最后减一是因为我们对 left 的更新必须是 left = mid + 1，就是说 while 循环结束时，nums[left] 一定不等于 target 了，而 nums[left-1] 可能是 target。
至于为什么 left 的更新必须是 left = mid + 1，同左侧边界搜索，就不再赘述。
3、为什么没有返回 -1 的操作？如果 nums 中不存在 target 这个值，怎么办？
类似之前的左侧边界搜索，因为 while 的终止条件是 left == right，就是说 left 的取值范围是 [0, nums.length]，所以可以添加两行代码，正确地返回 -1：

while (left < right) {
    // ...
}
if (left == 0) return -1;
return nums[left-1] == target ? (left-1) : -1;

4、是否也可以把这个算法的「搜索区间」也统一成两端都闭的形式呢？

int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 这里改成收缩左侧边界即可
            left = mid + 1;
        }
    }
    // 这里改为检查 right 越界的情况，见下图
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        if (len == 0) return -1;
        int left = 0,right = len - 1; // 搜索区间[left,right]
        while (left <= right) { // 结束条件：right + 1 == right
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) 
                return mid;
            else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        return -1;
    }
};