二分法之旋转数组系列

LeetCode 189. 旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
要求使用空间复杂度为 O(1) 的 原地 算法。

解法一　双重循环

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k %= n 
        for i in range(k):
            last = nums[n-1]
            for j in range(n-1,0,-1):
                nums[j] = nums[j - 1]
            nums[0] = last

双重循环
* 时间复杂度：O(kn)
* 空间复杂度：O(1)

解法二　插入法

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k %= n 
        while k:
            nums.insert(0, nums.pop())
            k -= 1
        

解法三　拼接法

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k %= n 
        nums[:] = nums[-k:] + nums[:-k]

解法四　三次翻转法

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k %= n 
        nums[:] = nums[::-1]
        nums[:k] = nums[:k][::-1]
        nums[k:] = nums[k:][::-1]

LeetCode 33. 搜索旋转排序数组

设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

解析：算法时间复杂度必须是 O(log n) 级别，所以只能用二分法．
先找中点，然后在有序的那一部分进行二分查找．
如果nums[mid] == target，恰好找到，返回mid
如果nums[mid] < nums[right]，则中点在右半部分，且mid和right之间这部分是有序的，接下来判断target是否在mid和right之间，如果是，收紧左边界，也即left=mid+1
如果nums[mid[ >=nums[right]，则中点在左半部分，且left和mid之间这部分是有序的，接下来判断target是否在left和mid之间，如果是，收紧右边界，也即right=mid-1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        n = len(nums)
        left = 0
        right = n - 1
        while left <= right:
            mid = left + (right - left) // 2
            if target == nums[mid]:
                return mid
            if nums[mid] < nums[right]:
                if nums[mid] < target and nums[right] >= target:
                    left = mid + 1
                else:
                    right = mid - 1
            else:
                if nums[mid] > target and nums[left] <= target:
                    right = mid - 1
                else:
                    left = mid + 1
        return -1

LeetCode 81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        n = len(nums)

        left = 0
        right = n - 1
        while left <= right:
            while left < right and nums[left] == nums[left + 1]:
                left += 1
            while left < right and nums[right] == nums[right - 1]:
                right -= 1
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return True
            if nums[mid] < nums[right]:
                if nums[mid] < target and nums[right] >= target:
                    left = mid + 1
                else:
                    right = mid - 1
            else:
                if nums[mid] > target and nums[left] <= target:
                    right = mid - 1
                else:
                    left = mid + 1
        return False