roufoo的博客

纸上学来终觉浅 绝知此事要躬行

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。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/roufoo/article/details/80322828
文章标签: Algorithm
个人分类: algorithm-design
想对作者说点什么? 我来说一句

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

不良信息举报

Binary Search 模板总结

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭