Binary Search 模板总结

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/roufoo/article/details/80322828

Binary Search 根据我的总结,可以分成离散和连续两类。离散就是一个排好序的数组里面找数,连续就是在[0,x]这个连续区间内找一个符合条件的解。因为0–x是自然连续增加的,所以当然可以用Binary Search。

离散Binary Search 通用模板:
离散Binary Search用前闭后开区间[a,b)和前闭后闭区间[a,b]都可以。前闭后开是一种STL风格的写法。这种写法的好处是:

  1. 给遍历元素时,循环的结束时机提供一个简单的判断依据。只要尚未到达end(),循环就可以继续下去。
  2. 不必对空区间采取特殊处理手段。空区间的begin()就等于end()。
    我们可以跟后面的前闭后闭一比较就可以看出来。前开后闭的写法要简单很多。但是注意它不能找重复元素出现的第一次或最后一次位置!!!因为会导致死循环。

前闭后开[start, end) 模板:

int binarySearch(vector<int> &a, int start, int end, int target) {
   int mid;
   while(start<end) {   //note it is start<end, not <=
        mid=start+(end-start)/2;
        if (a[mid]>target) 
             end=mid;
        else if (a[mid]<target)
             start=mid+1;
        else
             return mid;
  } 
  return -1;
}

注意:
1) 如果有重复元素的话,该模板返回该重复元素的任意位置(不一定是第一个,也不一定是最后一个)。
2) 需要特别注意的是,这种前开后闭区间的写法只能用于一旦找到就马上return pos的情况,而不能用于寻找重复元素出现的第一次或最后一次出现位置的情况,否则会导致死循环!这种情况下应该用下面的前闭后闭区间模板。

前闭后闭[start, end] 模板
前闭后闭递归版:

int findPos(vector<int> &a, int target) {
    return binarySearch(a, 0, a.size() - 1, target);
}
int binarySearch(vector<int> &a, int start, int end, int target) {
    if (start > end) return -1; 
    int mid = start + (end - start) / 2;
    if (a[mid] == target) return mid;   
    if (a[mid] < target) return binarySearch(a, mid + 1, end, target);
    return binarySearch(a, start, mid - 1, target);
}

注意我们不需要写if (start == end)的情况,因为如果start == end, 后面的mid = start, 再call
binarySearch(a, mid + 1, end, target)

binarySearch(a, start, mid - 1, target)
都会出现(start > end) 的情况。

前闭后闭循环版 (九章的版本):

int binarySearch(vector<int> nums, int start, int end, int target){
    if (nums.size() == 0 || start > end)
       return -1;
        
    int start = 0, end = len - 1;
    while (start + 1 < end) { //注意这里是start+1,是<不是<=
         int mid = start + (end - start) / 2;
            // 注意: =, <, > 三种情况,mid 不+1也不-1
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        
        // 注意,循环结束后,单独处理start和end
        if (nums[start] == target) {
            return start;
        }
        if (nums[end] == target) {
            return end;
        }
        return -1;
    }
}

2个主要问题及解答(from 九章):
Q: 为什么要用 start + 1 < end?而不是 start < end 或者 start <= end?
这是为了避免死循环。二分法的模板中分为两个部分:

  1. 通过 while 循环,将区间范围从 n 缩小到 2 (只有 start 和 end 两个点)。2)在 start 和 end 中判断是否有解。
    如果我们用start < end 或者 start <= end, 在寻找目标最后一次出现的位置的时候,会出现死循环。

Q: 为什么明明可以 start = mid + 1 偏偏要写成 start = mid?
A: 大部分时候,mid 是可以 +1 和 -1 的。在一些特殊情况下,比如寻找目标的最后一次出现的位置时,当 target 与 nums[mid] 相等的时候,是不能够使用 mid + 1 或者 mid - 1 的。因为会导致漏掉解。统一写成 start = mid / end = mid 并不会造成任何解的丢失,并且也不会损失效率——log(n) 和 log(n+1) 没有区别。

注意:
1) 如果有重复元素的话,该模板返回该重复元素的任意位置(不一定是第一个,也不一定是最后一个)。

2)当需要寻找重复元素出现的最后一个位置时,把return mid改为start = mid。最后两行顺序为

        if (nums[end] == target) return end;        
        if (nums[start] == target) return start;

3)当需要寻找重复元素出现的第一个位置时,把return mid改为end = mid。最后两行顺序为

        if (nums[start] == target) return start;
        if (nums[end] == target) return end;      
  1. 当需要寻找刚好小于或等于target的第一个元素时,我的理解是while()后的情况是start<=target<=end。
    如果target==end,返回target,
    否则返回start。即
        if (nums[end] == target) return end;
        return start;
  1. 当需要寻找刚好大于等于target的第一个元素时,与上面类似。

递归版:

int binarySearch(int[] nums, int start, int end, int target) {
    if (start > end) return -1;
    
    int mid = start + (end - start) / 2;
    if (nums[mid] == target) return mid;
    if (nums[mid] < target) return binarySearch(nums, mid + 1, end, target);
    return binarySearch(nums, start, mid - 1, target); 
}

连续Binary Search版本。跟离散版本差不多,而且还简单些。但是要注意找解的时候不能用==,而必须用一个很小的threshold来比较。小于这个threshold就可以认为相等. 下面是我写的一个double版的x/y的function(不用到/)。这里我认为double的被除数不会为0。欢迎指正。
代码如下:

#include <iostream>
#include <climits>
#include <cmath>
using namespace std;

double divideV(double x, double y) {
    //if (abs(y)<1e-6) return y>0 ? INT_MAX : INT_MIN;
    bool neg = false;

    if (x < 0 && y < 0) {x = -x; y = -y;}
    else if (x < 0) {neg = true; x = -x;}
    else if (y < 0)  {neg = true; y = -y;}

    double start = 0.0, end = x;

    while(start < end) {
        double mid = start + (end - start) / 2;
        if (abs(mid * y - x)<1e-6)
            return neg? -mid : mid;
        else if (mid*y - x < 0)
            start = mid;
        else
            end = mid;
    }
}

int main()
{
    cout << divideV(81.0, 7.0) << endl;
    cout << divideV(-81.0, 7.0) << endl;
    cout << divideV(81.0, -7.0) << endl;
    cout << divideV(-81.0, -7.0) << endl;
    return 0;
}

一些关于Binary Search的要点:

  1. Binary Search和Hash Table的比较:
    我们都知道Binary Search的复杂度是O(logn), 而Hash Table的复杂度是O(1)。但Hash Table有个问题是它的空间复杂度较大,而且Hash Table必须常驻内存,不能放在磁盘里面。
    而**Binary Search的数据不需要常驻内存,可以放在磁盘里面再读到内存里面。**所以Binary Search不受内存限制。文件系统通常都用Binary Search。
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页