假設有一個排序的按未知的旋轉軸旋轉的數組(比如，0 1 2 4 5 6 7 可能成為4 5 6 7 0 1 2)。給定一個目標值進行搜索，如果在數組中找到目標值返回數組中的索引位置，否則返回-1。

你可以假設數組中不存在重復的元素。

給出[4, 5, 1, 2, 3]和target=1，返回 2

給出[4, 5, 1, 2, 3]和target=0，返回 -1

考慮O(logN)復雜度，用二分法，重點在於如何放縮區間，也就是start 和 end的賦值

當有序數組旋轉後，某點 < A[0] 等價於在右邊序列 ， >A[0]等價於在左邊序列

所有情況分析如下:

mid 在左序列 ，target > [mid] 則 target一定在mid右邊。start = mid

mid 在左序列，target < [mid] 時有兩種情況，若target 在左序列，則target 在mid左邊，end = mid

　　　　　　　　　　　　　　　　　　　　若target在右序列，則target在mid 右邊，start = mid

右序列同理分析，

mid 在右序列 ，target < [mid] 則 target一定在mid 左邊。end = mid

mid 在右序列，target > [mid] 時有兩種情況，若target 在左序列，則target 在mid左邊，end = mid

　　　　　　　　　　　　　　　　　　　　若target在右序列，則target在mid 右邊，start = mid

class Solution:
    """
    @param: A: an integer rotated sorted array
    @param: target: an integer to be searched
    @return: an integer
    """
    def search(self, A, target):
        # write your code here
        if not A:
            return -1
  
        start, end = 0, len(A) - 1
        if
 
 A[start] > A[end]: #有旋轉
            while start + 1 < end:
                mid = (start + end) / 2
                
                if (A[mid] > A[-1] and target > A[mid]) or                 (A[mid] > A[-1] and target < A[mid] and target <= A[0]) or                 (A[mid] < A[0] and target > A[mid] and target <= A[0]):
                    start = mid 
                else:
                    end = mid 
                    
        else:#無旋轉，當做一般有序數組搜索
            while start + 1 < end:
                mid = (start + end) / 2
                if A[mid] < target:
                    start = mid
                elif A[mid] > target:
                    end = mid
                else :
                    return mid
                    
        if A[start] == target:
            return start
        elif A[end] == target:
            return end
        else:
            return -1

九章算法參考，更為簡潔但是有點難理解：

class Solution:
    """
    @param A : a list of integers
    @param target : an integer to be searched
    @return : an integer
    """
    def search(self, A, target):
        # write your code here
        l, h = 0, len(A) - 1
        while (l <= h):
            m = l + ((h - l) >> 1)
            if A[m] == target:
                return m
            elif (A[m] > A[l] and target < A[m] and target >= A[l]) or (A[m] < A[l] and not (target <= A[h] and target > A[m])):
                h = m - 1
            else:
                l = m + 1
        return -1

Lintcode_62.搜索旋轉排序數組