搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

思路：

算法时间复杂度为 O(log n)，即为二分查找：

简单的说就是先找到分割点（螺旋数组的递增分割点，最小值的索引），然后按照正常搜索递增数组目标值的方法二分查找目标值。

def search(nums,target):
  def findminindex(left,right):
      #找到数组中最小值的索引
      if nums[left]<nums[right]:
          #数组在这段是常规递增
          return 0
      while left<=right:
          mid=(left+right)//2
          if nums[mid]>nums[mid+1]:
              #符合条件的是螺旋式数组中的分界点，返回最小值的索引值
              return mid+1
          else:
              if nums[mid]<nums[left]:
                  right=mid-1
              else:
                  left=mid+1
  def searchnormal(left,right):
      while left<=right:
          mid=(left+right)//2
          if nums[mid]==target:
              return mid
          else:
              if nums[mid]>target:
                  right=mid-1
              else:
                  left=mid+1
      return -1
  n=len(nums)
  if n==0:return -1
  if n==1:return 0 if nums[0]==target else -1
  minindex=findminindex(0,n-1)
  if minindex==0:
      #如果最小值的索引为0，那么数组就是正常递增数组，直接搜索目标值
      return searchnormal(0,n-1)
  if target<nums[0]:
      #如果目标值小于数组的第一个值，那么就从最小值处往后搜索
      return searchnormal(minindex,n-1)
  return searchnormal(0,minindex)
nums=[4,5,6,7,0,1,2]
target=0
result=search(nums,target)
print(result)

直接使用二分法，判断那个二分点,有几种可能性

直接等于target

在左半边的递增区域

a. target 在 left 和 mid 之间

b. 不在之间

在右半边的递增区域

a. target 在 mid 和 right 之间

b. 不在之间

def search(nums, target):
    n = len(nums)
    if n == 0:
        return -1
    left = 0
    right = n - 1
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[left] <= nums[mid]:
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    # print(left,right)
    return left if nums[left] == target else -1