Search in Rotated Sorted Array

首先利用二分查找的方法找到最小值，然后在以最小值为分界的两块分别进行二分搜索。

int findPos(int A[], int left, int right){
    if(left > right)
        return -1;
    int mid = (left+right)/2;
    int result;
    if(A[left] > A[mid]){
        result = findPos(A, left, mid-1);
        if(result == -1)
            return mid;
        else
            return A[result]<A[mid]?result:mid;
    }
    else{
        result = findPos(A, mid+1, right);
        if(result == -1)
            return left;
        else
            return A[left]<A[result]?left:result;
    }
}
int bsearch(int A[], int left, int right, int target){
    if(left > right)
        return -1;
    int mid = (left+right)/2;
    if(A[mid] == target)
        return mid;
    else if(A[mid] < target)
        return bsearch(A, mid+1, right, target);
    else
        return bsearch(A, left, mid-1, target);
}
    int search(int A[], int n, int target) {
        int pos = findPos(A, 0, n-1);
        int result = bsearch(A, 0, pos-1, target);
        if(result != -1)
            return result;
        return bsearch(A, pos, n-1, target);
    }

 另外一种方法是直接二分，不过增加了一些判断，比上述代码要简练。

    int search(int A[], int n, int target) {
        if(n == 0)
            return -1;
        int l = 0, r = n-1, m;
        while(l <= r){
            m = (l+r)/2;
            if(A[m] == target)
                return m;
            else if(A[m] > A[l]){
                if(target < A[m] && target >= A[l])
                    r = m-1;
                else
                    l = m+1;
            }
            else if(A[m] < A[l]){
                if(target > A[m] && target <= A[r])
                    l = m+1;
                else
                    r = m-1;
            }
            else
                l++;
        }
        return -1;
    }