leetcode_33_81_153_154_旋转排序数组

---

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

解题

返回目标值的下标？

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        try:
            return nums.index(target)
        except:
            return -1

按照转折点和mid位置，分情况讨论，具体看注释

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-1
        while left <= right:
            mid = (left+right) // 2
            if nums[mid] == target:
                return mid
            # 转折点在mid左边
            if nums[left] > nums[mid]:
                # target在mid右边，此时mid右边为有序数据
                if target > nums[mid] and nums[right] >= target:
                    left = mid + 1
                # target在mid左边，right更新后，left到right间仍存在转折点
                else:
                    right = mid - 1

            # 转折点在mid右边
            else:
                # target在mid左边，此时mid左边为有序数据
                if nums[left] <= target and nums[mid] > target:
                    right = mid-1
                # target在右半边，left更新后，left到right间仍存在转折点
                else:
                    left = mid+1
        return -1

81.搜索旋转排序数组II

描述

中等

与上一题的差别就是，nums数据中可能包含重复元素

示例1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true

示例 2:

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

解题

增加一个去重就可以解决

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-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) // 2
            if nums[mid] == target:
                return True
            # 转折点在mid左边
            if nums[left] > nums[mid]:
                # target在mid右边，此时mid右边为有序数据
                if target > nums[mid] and nums[right] >= target:
                    left = mid + 1
                # target在mid左边，right更新后，left到right间仍存在转折点
                else:
                    right = mid - 1
            # 转折点在mid右边
            else:
                # target在mid左边，此时mid左边为有序数据
                if nums[left] <= target and nums[mid] > target:
                    right = mid-1
                # target在右半边，left更新后，left到right间仍存在转折点
                else:
                    left = mid+1
        return False

153.寻找旋转排序数组中的最小值

描述

中等

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

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

请找出其中最小的元素。

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

示例 1:

输入: [3,4,5,1,2]
输出: 1

示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

解题

这题目，真想一行解决战斗

class Solution:
    def findMin(self, nums: List[int]) -> int:
        return min(nums)

题目将有序数组分成左右，然后左右两部分交换形成新数组
两部分都是升序的，且前一部分的数据都比后一部分的数据大
相当于是查找后一部分的第一个值

可以用二分解决

• 当mid上的数据小于right时，说明mid已经处于后一部分
• 当mid上的数据大于right时，说明mid处于前一部分

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

154.寻找旋转排序数组中的最小值II

描述

困难

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

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

请找出其中最小的元素。

注意数组中可能存在重复的元素。

示例 1：

输入: [1,3,5]
输出: 1

示例 2：

输入: [2,2,2,0,1]
输出: 0

解题

和上一题的区别就是数据中的数据可能出现重复

每次使用left和right时进行去重操作
并且在判断条件中加入等号

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left = 0
        right = len(nums) - 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) // 2
            if nums[mid] <= nums[right]:
                right = mid
            else:
                left = mid + 1
            
        return nums[left]

当mid上的数据等于right上的数据时
若mid落在前一部分，在某点旋转时，这个点的值的数据比较多，将这个点的数据段分成了两部分

12|22223 -> 22223|12

mid落在后一部分时，后段数据有一段相同

12222|23 -> 23|12222

mid上数据和right上数据相同时，可以通过right-=1来调整
就变成了上一题的情况

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left = 0
        right = len(nums) - 1

        while left < right:
            mid = (left+right) // 2
            if nums[mid] < nums[right]:
                right = mid
            elif nums[mid] > nums[right]:
                left = mid + 1
            else:
                right -= 1
            
        return nums[left]