二分查找－BinarySearch

算法基本思想

前置条件:一个有序的序列(假设升序排列),在序列中查找指定元素
算法：首先与序列中间的元素进行比较,如果大于这个元素,就在当前序列的后半部分继续查找,如果小于这个元素,就在当前序列的前半部分继续查找,直到找到相同的元素,或者所查找的序列范围为空为止。

算法代码

int binarySearch(vector<int> &vec, int value){
    int left,mid,right;
    left=0;
    right=vec.size()-1;

    while(left<=right){     //小于或者等于
        mid=left+(right-left)/2;    //(left+right)/2可能会溢出
        if(value<vec[mid]){
            right=  mid-1;
        }else if(value>vec[mid]){
            left=   mid+1;
        }else{
            return mid;
        }

    return -1;
}

上面是基于左闭右闭的区间搜索，下面有一种基于左闭右开的搜索：

int binarySearch(vector<int> &vec, int value){
    int left,mid,right;
    left=0;
    right=vec.size();

    while(left<right){     //小于
        mid=left+(right-left)/2;    //(left+right)/2可能会溢出
        if(value<vec[mid]){
            right=  mid;
        }else if(value>vec[mid]){
            left=   mid+1;    //制造left=mid+1(相对的high=mid-1没什么用)
        }else{
            return mid;
        }

    return -1;
}

溢出
在循环体内,计算中间位置的时候,很多人喜欢使用的是这个表达式:
middle = (left + right) / 2;

假如,left与right之和超过了所在类型的表示范围的话,那么middle就不会得到正确的值.
所以,更稳妥的做法应该是这样的:
middle = left + (right - left) / 2;

优化比较次数

上面的算法都是每次迭代3次比较，有没有方法优化并减少比较次数呢？答案是肯定的。
下面给出一个2次比较的代码：

int binarySearch3(vector<int> &vec, int value){
    int left,mid,right;
    left=0;
    right=vec.size()-1;

    while(left<right){
        mid=left+(right-left)/2;
        if(value>vec[mid]){
            left = mid+1;
        }else{
            right = mid;
        }
    }

    if(vec[left]==value){
        return left;
    }else{
        return -1;
    }
}

题外话

我个人更喜欢另外一种写法，这种写法在遇到旋转扩展的时候更好改思路：

//左闭右闭，我比较喜欢的一种写法，扩展方便
int binarySearch4(vector<int> &vec, int value){
    int left,mid,right;
    left=0;
    right=vec.size()-1;

    while(left<=right){     //小于或者等于
        mid=left+(right-left)/2;
        if(value==vec[mid]){
            return mid;
        }
        if(value<vec[mid]){
            right=  mid-1;
        }else if(value>vec[mid]){
            left=   mid+1;
        }
    }
    return -1;
}

复杂度分析

二分查找算法的时间复杂度为O(logN)