Binary Search 模板总结

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

离散Binary Search 通用模板：
离散Binary Search用前闭后开区间[a,b)和前闭后闭区间[a,b]都可以。前闭后开是一种STL风格的写法。这种写法的好处是：
1) 给遍历元素时，循环的结束时机提供一个简单的判断依据。只要尚未到达end()，循环就可以继续下去。
2)不必对空区间采取特殊处理手段。空区间的begin()就等于end()。
我们可以跟后面的前闭后闭一比较就可以看出来。前开后闭的写法要简单很多。但是注意它不能找重复元素出现的第一次或最后一次位置！！！因为会导致死循环。

1) 前闭后开区间[start, end)：
循环版：

int binarySearch(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的情况，而不能用于寻找重复元素出现的第一次或最后一次出现位置的情况，否则会导致死循环！这种情况下应该用下面的前闭后闭区间模板。

递归版：

int binarySearch(int a[], int start, int end, int target) {
    if (start>=end) return -1;   //note the >= here.
    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, target);
}

2) 前闭后闭区间[start, end]
循环版 (九章的版本)：

int binarySearch(int[] nums, int start, int end, int target){
    if (nums == null || 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改为end=mid。最后两行顺序为

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

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

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

递归版：

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。

Binary Search 模板总结

猜你喜欢