二分搜索及其变形讨论

最近刷leetcode的时候遇到了不少二分查找的题，二分查找是非常高效的查找策略，但是有一个前提就是数组必须是有序的。

1. 对于标准的二分搜索，针对的是没有重复元素的有序数组，每个元素只出现一次。标准的二分搜索的代码很简洁，对于程序员来讲最好会背

int std_binary_search(int v[], int n, int target)
{
    int l,r,m;

    l = 0;
    r = n - 1;

    while(l <= r)
    {
        m = l + (r - l) / 2;
        if(v[m] == target)
            return m;
        else if(v[m] > target)
            r = m - 1;
        else
            l = m + 1;
    }

    //l is the position in which target will be inserted
    return l;
}

需要注意的是如果查找的目标不在数组中所返回的值，一般情况下返回-1比较好，但是如果要求返回target插入到数组中的位置，那么可以返回l，但是需要注意的就是返回之后一定要验证v[l]是不是taget，因为无法判断返回的这个位置是target还是待插入的位置。

2. 如果数组中有重复的元素，而且二分查找的时候要求返回重复元素的起始位置和结束位置，那么上面的代码就不管用了。主要解决思路是进行两次二分搜索，第一次找到最左边的target，第二次找到最右边的target。程序的代码基本不变，但是需要修改判断条件，代码如下，可以对比上面的程序注意一下修改的判断条件。

//if the array has duplicate elements
vector<int> dup_binary_search(int v[], int n, int target)
{
    int l,r,m;
    int left_p,right_p;

    l = 0;
    r = n - 1;
    //find the most left position
    while(l <= r)
    {
        m = l + (r - l) / 2;
        if(v[m] >= target)
            r = m - 1;
        else
            l = m + 1;
    }
    left_p = l;

    //find the most right position
    l = 0;
    r = n - 1;
    while(l <= r)
    {
        m = l + (r - l) / 2;
        if(v[m] <= target)
            l = m + 1;
        else
            r = m - 1;
    }
    right_p = r;
    vector<int> result;
    if(v[left_p] == v[right_p])
    {
        result.push_back(left_p);
        result.push_back(right_p);
    }
    else
    {
        result.push_back(-1);
        result.push_back(-1);
    }
    return result;
}

3. 第三种情况就是数组旋转过，即一个有序的数组平移了若干个元素，比如[6,7,0,1,2,3,4,5]这个数组，如果在这个数组中找到目标元素，使用二分查找也是可以的。首先我们可以观察到一点，就是如果从数组的中间的元素分开，那么一定有一半是有序数组，而另外一半是一个旋转过的有序数组，这样就可以进行判断，如果target在有序的部分，直接使用标准的二分策略就可以，如果落在另一半，那么重复上面的过程就可以了。

//if the array has been translation like [5,6,7,1,2,3,4]
int trans_binary_search(int v[], int n ,int target)
{
    int l,r,m;
    l = 0;
    r = n - 1;
    while(l <= r)
    {
        m = l + (r - l) / 2;
        if(v[m] == target)
            return m;
        //if the left part is in right order
        else if(v[l] <= v[m])
        {
            if(target >= v[l] && target < v[m])
                r = m - 1;
            else
                l = m + 1;
        }
        //if the right part is in right order
        else
        {
            if(target <= v[r] && target > v[m]) 
                l = m + 1;
            else
                r = m - 1;
        }
    }
    return -1;
}