來說說二分查找

二分查找是我們經常會遇到的算法，思路清晰，代碼簡潔。二分查找要求序列有序，且支持隨機存取，一般情況下我們討論的序列不存在相同元素，則二分查找可以很熟練的表示如下：

int binsearch(int A[], int n, int target)
    {
        int left=0,right=n-1,res=-1;
        while(left<=right)
        {
            int mid = left+((right-left)>>1);
            if(A[mid]<target)
                left = mid+1;
            else if(A[mid]>target)
                right = mid-1;
            else
            {
                return mid;
            }
        }
        return -1;
    }

但是當我們對有序序列不做要求時，即可能出現相同的元素的情況下，二分查找就回出現一些擴展的問題，比如：

1. 返回key的第一次出現的下標，若沒有返回-1；
2. 返回key最後一次出現的下標，若沒有返回-1；
3. 返回剛好小於key的元素的下標，若沒有返回-1；
4. 返回剛好大於key的元素的下標，若沒有返回-1； 

對於（1）而言，當查找到與key相同的元素時，並不馬上返回，而是先記錄下來，然後繼續查找左邊是否還存在與key相同的元素。

int searchLowerBound(int A[], int n, int target)
    {
        int left=0,right=n-1,res=-1;
        while(left<=right)
        {
            int mid = left+((right-left)>>1);
            if(A[mid]<target)
                left = mid+1;
            else if(A[mid]>target)
                right = mid-1;
            else
            {
                res = mid;
                right = mid-1;
            }
        }
        return res;
    }

對於（2），同理可得：

int searchHigherBound(int A[], int n, int target)
    {
        int left=0,right=n-1,res=-1;
        while(left<=right)
        {
            int mid = left+((right-left)>>1);
            if(A[mid]<target)
                left = mid+1;
            else if(A[mid]>target)
                right = mid-1;
            else
            {
                res = mid;
                left = mid+1;
            }
        }
        return res;
    }

對於（3），使得key=key-1，則轉換成問題（2），對於（4），使得key=key+1，則轉換成問題（1）。

下面我以一個leetcode中出現的二分查找的題目爲例:search for a range

題目描述：

Given a sorted array of integers, find the starting and ending position of a given target value.Your algorithm's runtime complexity must be in the order of O(log n).If the target is not found in the array, return [-1, -1].

For example,

Given [5, 7, 7, 8, 8, 10] and target value 8,

return [3, 4].

這個題就是要求出最小的value的下標和最大的value的下標，所以代碼易得：

class Solution {
public:
    int searchLowerBound(int A[], int n, int target)
    {
        int left=0,right=n-1,res=-1;
        while(left<=right)
        {
            int mid = left+((right-left)>>1);
            if(A[mid]<target)
                left = mid+1;
            else if(A[mid]>target)
                right = mid-1;
            else
            {
                res = mid;
                right = mid-1;
            }
        }
        return res;
    }
    
     int searchHigherBound(int A[], int n, int target)
    {
        int left=0,right=n-1,res=-1;
        while(left<=right)
        {
            int mid = left+((right-left)>>1);
            if(A[mid]<target)
                left = mid+1;
            else if(A[mid]>target)
                right = mid-1;
            else
            {
                res = mid;
                left = mid+1;
            }
        }
        return res;
    }
    
    vector<int> searchRange(int A[], int n, int target) {
        vector<int> res;
        res.push_back(searchLowerBound(A,n,target));
        res.push_back(searchHigherBound(A,n,target));
        return res;
    }
};