旋转数组
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 m o d n k\bmod n kmodn个元素会移动至数组头部,其余元素向后移动 k m o d n k\bmod n kmodn个位置。
2、该方法为数组的翻转:我们可以先将所有元素翻转,这样尾部的 k m o d n k\bmod n kmodn个元素就被移至数组头部,然后我们再翻转 [0, k m o d n k\bmod n kmodn-1]区间的元素和 [ k m o d n k\bmod n kmodn, 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(n) O(n)
- 空间复杂度: O ( 1 ) O(1) 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 ( l o g n ) O(logn) O(logn)
- 空间复杂度: O ( 1 ) O(1) 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 ( l o g n ) O(logn) O(logn)
- 空间复杂度: O ( 1 ) O(1) 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 ( l o g n ) O(logn) O(logn)
- 空间复杂度: O ( 1 ) O(1) 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