Algorithm 旋转数组中的搜索

立法会问题:

var search=函数（nums，目标）{
设左=0，右=nums.length-1；
while（左<右）{
让中间=左+数学楼层（（右-左）/2）；
如果（nums[mid]nums[mid]&&target nums[mid]| | target

---

有人能解释一下为什么如果右侧没有排序，如果target我们会重新校准搜索空间以向右看吗？什么样的情况会导致这种情况是真的？

@MikeChan，不是回答你的问题，而是问题。通过嵌入注释/解释，代码更易于阅读：

 def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums) - 1
        
        while left <= right:
            mid = (left + right) // 2
            # if found target value, return the index
            if nums[mid] == target:
                return mid
            
            # determine it's left rotated or right rotated
            """
            No rotated:
            1 2 3 4 5 6 7 8 9 10
                         mid
                 
            left rotated: pivot at the left side of the origin sorted array, A[mid] >= A[left]
            6 7 8 9 10 1 2 3 4 5
               mid
            search in A[left] ~ A [mid] if A[left] <= target < A[mid] else, search right side
            
            right rotated: pivot at the right side of the origin sorted array, A[mid] < A[left]
            6 7 8 9 10 1 2 3 4 5 
               mid          
            search in A[mid] ~ A[right] if A[mid] < target <= A[right] else, search left side
            """
            if nums[mid] >= nums[left]: # left rotated
                # in ascending order side
                if nums[left] <= target and target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else: # right rotated
                # in ascending order side
                if nums[mid] < target and target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        # cannot find the target value
        return -1

def搜索（self，nums:List[int]，target:int）->int:
左，右=0，len（nums）-1
离开时
 def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums) - 1
        
        while left <= right:
            mid = (left + right) // 2
            # if found target value, return the index
            if nums[mid] == target:
                return mid
            
            # determine it's left rotated or right rotated
            """
            No rotated:
            1 2 3 4 5 6 7 8 9 10
                         mid
                 
            left rotated: pivot at the left side of the origin sorted array, A[mid] >= A[left]
            6 7 8 9 10 1 2 3 4 5
               mid
            search in A[left] ~ A [mid] if A[left] <= target < A[mid] else, search right side
            
            right rotated: pivot at the right side of the origin sorted array, A[mid] < A[left]
            6 7 8 9 10 1 2 3 4 5 
               mid          
            search in A[mid] ~ A[right] if A[mid] < target <= A[right] else, search left side
            """
            if nums[mid] >= nums[left]: # left rotated
                # in ascending order side
                if nums[left] <= target and target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else: # right rotated
                # in ascending order side
                if nums[mid] < target and target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        # cannot find the target value
        return -1