問題1 搜尋插入位置
給定一個排序陣列和一個目標值，如果在陣列中找到目標值則返回索引。如果沒有，返回到它將會被按順序插入的位置。

你可以假設在陣列中無重複元素。

樣例
[1,3,5,6]，5 → 2

[1,3,5,6]，2 → 1

[1,3,5,6]， 7 → 4

[1,3,5,6]，0 → 0

挑戰
O(log(n)) time

def searchInsert(self, A, target):
        # write your code here
        n=len(A)
        if(n==0):
            return 0
 

        left,right=0,n-1
        while(right>left and (right-left)!=1):
            mid=left+((right-left)>>1)
            if(A[mid]>target):
                right=mid
            elif(A[mid]<target):
                left=mid
            else:
                return mid
        if(target<=A[left
 
]):
            return left
        elif(A[right]<target):
            return right+1

        else:
            return right

思路：
要求O(log(n)) time,顯示是二分法求解，一步步找出target在陣列中的位置，當只剩下left和right兩個元素時候，比較他們與target的關係，即可以找到要插入的位置。

問題2 搜尋旋轉排序陣列
假設有一個排序的按未知的旋轉軸旋轉的陣列(比如，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) time

def searchInsert(self, A, target):
        # write your code here
        n=len(A)
        if(n==0):
            return 0
        left,right=0,n-1
        while((right-left)>1):
            mid=left+((right-left)>>1)
            if(A[mid]>target):
                right=mid
            elif(A[mid]<target):
                left=mid
            else:
                return mid
        if(target==A[left]):
            return left
        elif(A[right]==target):
            return right
        else:
            return -1
    def search(self, A, target):
        # write your code here
        n=len(A)
        if n==0:
            return -1
        location=-1
        for i in range(n-1):
            if(A[i+1]-A[i]<0):
                location=i
        if location==-1:
            return Solution.searchInsert(self=self,A=A,target=target)
        else:
            arrRight=A[(location+1):]
            arrLeft=A[:(location+1)]
            print('loc',location)
            if(target<=A[n-1]):
                indRight=Solution.searchInsert(self=self,A=arrRight,target=target)
                print('indRight',indRight)

                return location+1+indRight if indRight!=-1 else -1

            elif(target>=A[0]):
                indLeft=Solution.searchInsert(self=self,A=arrLeft,target=target)
                print('indLeft',indLeft)
                return indLeft if indLeft!=-1 else -1
            else:
                return -1

思路：
與之前的問題有一點不同的是，這裡如果陣列中不存在target則返回-1；
先找旋轉陣列中的boundary(也要考慮到這個陣列沒有boundary，就是一個順序陣列的情況)。
找到boundary之後，將陣列分成兩個小陣列，然後分別應用搜索插入位置的演算法即可。對於右邊陣列，在得到插入位置之後，還需要加一個boundary大小。