描述

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.

分析

这道题目不难，主要是性能问题。常规解法如下：

class Solution{
public:
    int search(int A[],int n,int target){
        for(int i = 0; i != n; ++i){
            if(A[i] == target)  //if found
                return i;       //return its index
        }
        return -1;  //otherwise return -1
    }
}

该算法时间复杂度为O(n)，空间复杂度为O(1)。

事实上用二分查找算法会获得更好的性能。

由于本题的有序数组是经过“旋转”的，因此只是部分有序。

以题目所给数组为例，[4 5 6 7 0 1 2]在经过旋转后，整个数组变得无序，但是0两侧的部分数组是有序的。根据二分算法的思想，进行查找的步骤如下：

• 若A[first] < A[mid]，则说明[first,mid)这个区间是有序的，再在这个区间内进行二分查找：

  若A[first] <= target 并且target < A[mid] ，则target必在此有序区间中，修改last的值为mid；

  否则，说明target在另一半区间（可能是无序的），修改first的值为mid+1；

• 若A[first] >= A[mid]，则说明该区间无序（那么另一区间是有序的），同样在这个区间进行二分查找：

  若A[mid] < target 并且 target <= A[last – 1]，则说明target在另一半有序区间中，修改first的值为mid+1（注意这一步，比较的是另一半有序区间）；

  否则，说明target在本区间（是无序的），修改last的值为mid；

• 重复以上过程，直到找到target或遍历结束（first == last）；若遍历结束仍未找到，返回-1，否则，返回mid。

该算法的重点在于，必须要对两个区间分别进行查找，并且只在有序区间对target进行二分查找（旋转过后必然会有一区间有序，一区间无序，而不可能同时无序），target要么在有序的一部分，要么在无序的一部分，要么不存在。且若能找到target，必然会是mid的下标

class Solution{
public:
    int search(int A[],int n,int target){
        int search(int A[],int n,int target){
            int first = 0,last = n;
            int mid = (first + last) / 2;
            while(first != last){
                if(A[mid] == target)    //if found,the target value's index must be mid
                    return mid;
                if(A[first] < A[mid]){  //if ordered
                    if(A[first] <= target && target < A[mid])   //if target is in [first,mid)
                        last = mid;
                    else    //if not
                        first = mid + 1;
                }else{  //if unordered
                    if(A[mid] <= target && target < A[last - 1])    //if in [mid,last-1)
                        first = mid + 1;
                    else    //otherwise
                        last = mid;
                }
            }
            return -1;  //if not found,return -1
        }
    }
}

该算法时间复杂度为

O(log_2n)

空间复杂度为O(1)。

（题目没有说明该数组是递增有序还是递减有序，真奇怪。这里默认递增。）