LeetCode之二分查找之旋转数组系列题

1、旋转数组（189）

题目描述：

【中等题】
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

进阶：

1、尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
2、你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例一：

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

题目链接

思路分析：

1、当我们将数组的元素向右移动 k 次后，尾部 $k\mathrm{m}\mathrm{o}\mathrm{d}n$个元素会移动至数组头部，其余元素向后移动 $k\mathrm{m}\mathrm{o}\mathrm{d}n$个位置。

2、该方法为数组的翻转：我们可以先将所有元素翻转，这样尾部的$k\mathrm{m}\mathrm{o}\mathrm{d}n$个元素就被移至数组头部，然后我们再翻转 [0, $k\mathrm{m}\mathrm{o}\mathrm{d}n$-1]区间的元素和 [$k\mathrm{m}\mathrm{o}\mathrm{d}n$, n-1]区间的元素即能得到最后的答案。

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def reverse(left,right):
            while left<right:
                nums[left],nums[right]=nums[right],nums[left]
                left+=1
                right-=1
        n=len(nums)
        # 向右移动的位置k可能会大于n，因此对n取余
        k=k%n
        if k==0 or n<2:
            return 
        # 以此为例：nums = [1,2,3,4,5,6,7], k = 3
        # 先整个数组反转：[7,6,5,4,3,2,1]
        reverse(0,n-1)
        # 前k个反转：[5,6,7,4,3,2,1]
        reverse(0,k-1)
        # 后n-k个反转：[5,6,7,1,2,3,4]
        reverse(k,n-1)

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

2、寻找旋转数组中的最小值（153）

题目描述：

【中等题】
假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] 。

请找出其中最小的元素。
示例 1：

输入：nums = [3,4,5,1,2]
输出：1

题目链接

思路分析：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left=0
        right=len(nums)-1
        while left<right:
        	mid=left+(right-left)//2
        	# 中间数字大于右边数字，比如[3,4,5,1,2]，则左侧是有序上升的，最小值在右侧
            if nums[mid]>nums[right]:
                left=mid+1
            else:
                # 中间数字小于等于右边数字，比如[6,7,1,2,3,4,5]，则右侧是有序上升的，最小值在左侧
                right=mid
        return nums[left]

• 时间复杂度：$O(logn)$
• 空间复杂度：$O(1)$

3、寻找旋转数组中的最小值II（154）

题目描述：

【困难题】

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

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

请找出其中最小的元素。

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

示例 1：

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

说明：

• 这道题是 寻找旋转排序数组中的最小值 的延伸题目。
• 允许重复会影响算法的时间复杂度吗？会如何影响，为什么？

题目链接

思路分析：

1、这道题相当与上一道题难度是可能存在重复元素，那么light指针不能直接移到mid位置，因为有可能下一次取mid值遗漏掉最小值。

2、如果中间元素=区间尾元素，right减一

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left=0
        right=len(nums)-1
        while left<right:
            mid=left+(right-left)//2
             # 中间数字大于右边数字，比如[3,4,5,1,2]，则左侧是有序上升的，最小值在右侧
            if nums[mid]>nums[right]:
                left=mid+1
             # 中间数字小于右边数字，比如[6,7,1,2,3,4,5]，则右侧是有序上升的，最小值在左侧
            elif nums[mid]<nums[right]:
                right=mid
            else:
            	# 中间数字等于右边数字，比如[2,3,1,1,1]或者[4,1,2,3,3,3,3]
                # 则重复数字可能为最小值，也可能最小值在重复值的左侧
                # 所以将right左移一位

                right-=1
        return nums[left]

• 时间复杂度：平均时间复杂度为 O(logn)，如果数组是随机生成的，那么数组中包含相同元素的概率很低，在二分查找的过程中，大部分情况都会忽略一半的区间。而在最坏情况下，如果数组中的元素完全相同，那么 while 循环就需要执行 n 次，每次忽略区间的右端点，时间复杂度为 O(n)。
• 空间复杂度：O(1)。

4、搜索旋转排序数组（33）

题目描述：

【中等题】

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的索引，否则返回 -1 。

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

题目链接

思路分析：

理论部分

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1
        left=0
        right=len(nums)-1
        while left<=right:
            mid=left+(right-left)//2
            if nums[mid]==target:
                return mid
            #如果旋转点（即旋转数组）在中位数的右边,则中位数左半部分是有序的
            if nums[mid]>nums[right]:
                # target落在左半部分有序区域内
                if nums[0]<=target<nums[mid]:
                    right=mid-1
                else:
                    # target落在右半部分无序区域内
                    left=mid+1
            #如果旋转点（即旋转数组）在中位数的左边,则中位数右半部分是有序的
            else:
                # target落在右半部分有序区域内
                if nums[mid]<target<=nums[right]:
                    left=mid+1
                else:
                    # target落在左半部分无序区域内
                    right=mid-1
        return -1

• 时间复杂度：$O(logn)$
• 空间复杂度：$O(1)$

5、搜索旋转排序数组II（81）

题目描述：

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

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

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

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

进阶:

• 这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
• 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

题目链接

思路分析：

1、这道题相当与上一题区别在于这道题包含了重复元素，其实影响到的是，当左端点和右端点相等时，无法判断mid在左半边有序数组还是右半边有序数组，所以只需要一直pop直到左端点和右端点不相等就可以了。就加上两句话即可：

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        if not nums:
            return -1
       
        while len(nums) > 1 and nums[0] == nums[-1]:
            nums.pop()
        
        left=0
        right=len(nums)-1
        while left<=right:
            mid=left+(right-left)//2
            if nums[mid]==target:
                return True
            #如果旋转点（即旋转数组）在中位数的右边,则中位数左半部分是有序的
            if nums[mid]>nums[right]:
                # target落在左半部分有序区域内
                if nums[0]<=target<nums[mid]:
                    right=mid-1
                else:
                    # target落在右半部分无序区域内
                    left=mid+1
            #如果旋转点（即旋转数组）在中位数的左边,则中位数右半部分是有序的
            else:
                # target落在右半部分有序区域内
                if nums[mid]<target<=nums[right]:
                    left=mid+1
                else:
                    # target落在左半部分无序区域内
                    right=mid-1
        return False

• 时间复杂度：$O(logn)$
• 空间复杂度：$O(1)$

6、面试题10.03 搜索旋转数组

题目描述：

【中等题】

搜索旋转数组。给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次了，次数不详。请编写代码找出数组中的某个元素，假设数组元素原先是按升序排列的。若有多个相同元素，返回索引值最小的一个。

示例1:

 输入: arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 5
 输出: 8（元素5在该数组中的索引）

class Solution:
    def search(self, arr: List[int], target: int) -> int:
      
        left=0
        right=len(arr)-1
        while left<=right:
            # 重点1：当left符合时直接返回, 因为找的是最小的索引
            if arr[left]==target:
                return left
            mid=left+(right-left)//2
            # 重点2：当中间值等于目标值，将右边界移到中间，因为左边可能还有相等的值
            if arr[mid]==target:
                right=mid
            #如果旋转点（即旋转数组）在中位数的右边,则中位数左半部分是有序的
            #elif arr[0]<arr[mid]:或者
            elif arr[mid]>arr[right]:
                 # target落在左半部分有序区域内
                if arr[0]<=target<arr[mid]:
                    right=mid-1
                else:
                    left=mid+1
            #如果旋转点（即旋转数组）在中位数的左边,则中位数右半部分是有序的
            #elif arr[0]>arr[mid]:或者
            elif arr[mid]<arr[right]:
                if arr[mid]<target<=arr[right]:
                    left=mid+1
                else:
                    right=mid-1
            else:
                # 重点3：当中间数字与右边数字相等时，将右边界左移
                    right-=1
        return -1

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        size=len(nums)
        if size==0:
            return [-1,-1]
        first_popstion=self.find_first_index(nums,size,target)
        if first_popstion==-1:
            return [-1,-1]
        last_popstion=self.find_last_index(nums,size,target)
        return [first_popstion,last_popstion]
        
    #寻找开始位置，即找到第一个
    def find_first_index(self,nums,size,target):
        left=0
        right=size-1
        while left<=right:
            if nums[left]==target:
                return left 
            
            mid=left+(right-left)//2
            if nums[mid]<target:
                left=mid+1
            elif nums[mid]==target:
                right=mid
            else:
                right=mid-1
        
        return -1
    #寻找结束位置
    def find_last_index(self,nums,size,target):
        left=0
        right=size-1
        while left<=right:
            if nums[right]==target:
                return right 
            
            mid=left+(right-left)//2
            if nums[mid]<target:
                left=mid+1
            elif nums[mid]==target:
                left=mid
            else:
                right=mid-1
        
        return -1