查找已排序的旋转后的数组中的数（Search in Rotated Sorted Array）

题目如下：

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

分析：此题最简单的方法就是一个个比较，复杂度O(N)，但这样就没有利用分段排序这个条件。

我的想法是先用二分搜索将数组分成两个已排序的数组，再在这两个数组上查找，这样算法复杂度为O(lgN)+max（O(lgM)+O(lg(N-M))），其中0<M<N

代码如下：

 int findmax(int A[], int n){
        int max=A[0];
        int i=0,j=n-1,m=i+(j-i)/2+1;
        while(i!=j)
        {
           if(max<A[m])
           {
               i=m;
               max=A[m];
           }
           if(max>A[m])j=m-1;
           m=i+(j-i)/2+1;
        }
        return i;
    }
    int binarysearch(int A[], int n, int target)
    {
        int i=0,j=n-1,m=i+(j-i)/2;
        while(i<=j)
        {
           if(target==A[m])break;
           if(target<A[m])j=m-1;
           if(target>A[m])i=m+1;
           m=i+(j-i)/2;
        }
        if(i<=j)return m;
        return -1;
    }
    int search(int A[], int n, int target) {
        if(n<=0)return -1;
        int position=findmax(A,n);
        int result=binarysearch(A, position+1, target);
        if(result!=-1)return result;
        if(n>position+1)
        {
            result=binarysearch(A+position+1, n-position-1, target);
            if(result!=-1)return result+position+1;
        }
        return -1;
    }