【python数据结构与算法】LeetCode33.搜索旋转排序数组

题目链接：LeetCode 33

---

题目内容：

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例， [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)，所以很容易让人想到二分查找。所以笨蛋的思路就很简单：

• 先判断数组是否旋转了。
  • 若有旋转，二分找到旋转数组旋转的位置在哪，并记录旋转位置、将数组旋转回原本的升序
• 再接一个二分，对已修正过的升序数组进行二分查找，找到target的位置。当然返回原位置时，应注意要对现位置进行简单处理，找到修正旋转前的位置。

闲话少叙，上code：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if not nums:           # 排除为空的目标数组
            return -1
        
        flag = True            # 专门用于记录是否数组需要旋转（若数组第一个数大于最后一个，则需要旋转），True表示为需要旋转，数组不是升序
        lo,hi = 0,len(nums)-1
        if nums[lo] >= nums[hi]:     # 第一个二分，找数组里出最小的数，该数的位置就是旋转点
            flag = False
            while hi - lo > 1:
                mid = (lo + hi) >> 1
                if nums[mid] > nums[hi]:
                    lo = mid
                else:
                    hi = mid
            nums = nums[hi:] + nums[:hi]
       
        start,end = 0,len(nums)-1
        n = len(nums) - hi
        while start <= end:          # 第二个二分，就是普通的二分查找
            m = (start + end) >> 1
            if nums[m] == target:
                if not flag:        # 判断一下数组是否经过旋转，若没旋转过，就直接返回m；否则要经过一个简单的处理
                    return (m - n) if (m - n) >= 0 else (len(nums) + m - n)
                else:
                    return m
            elif nums[m] > target:
                end = m - 1
            else:
                start = m + 1
        return -1

以上code的结果是，执行用时击败了8.72%的用户，内存小号击败了0.93%的用户——简直是醉了。。。

---

更聪明的办法

思路：仍旧采用二分逼近，但其实我们没必要非得把旋转数组再旋转回来，直接将数组处理成两段升序数组就好。

• 直接进行二分，若mid位置的数 == target，则找到了，直接return
• 若mid位置 != target，则需要分类处理：
  • 若mid位置的数大于lo位置（数组第一个位置）的数，意味着mid左侧是升序：
    • 若target在左侧升序数组范围内，在这部分进行二分；
    • 若target不在左侧（在右侧），则lo = mid + 1，进行下一轮右侧的升序判断
  • 若mid位置的数小于hi（数组最后一个位置）的数，意味着mid右侧是升序：
    • 若target在右侧升序数组范围内，在这部分进行二分；
    • 若target不在右侧（在左侧），则hi = mid - 1，进行下一轮左侧的升序判断

上code：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if not nums:
            return -1
        
        lo,hi = 0,len(nums)-1
        while lo <= hi:
            mid = (lo + hi) >> 1
            if nums[mid] == target:
                return mid
            
            if nums[mid] >= nums[lo]:
                if nums[lo] <= target < nums[mid]:
                    hi = mid-1
                else:
                    lo = mid + 1
            else:
                if nums[mid] < target <= nums[hi]:
                    lo = mid + 1
                else :
                    hi = mid - 1
        return -1