153. 寻找旋转排序数组中的最小值
难度中等568
已知一个长度为 n
的数组,预先按照升序排列,经由 1
到 n
次 旋转 后,得到输入数组。例如,原数组 nums = [0,1,2,4,5,6,7]
在变化后可能得到:
- 若旋转
4
次,则可以得到[4,5,6,7,0,1,2]
- 若旋转
7
次,则可以得到[0,1,2,4,5,6,7]
注意,数组 [a[0], a[1], a[2], ..., a[n-1]]
旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]
。
给你一个元素值 互不相同 的数组 nums
,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
示例 1:
输入:nums = [3,4,5,1,2]
输出:1
解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。
示例 2:
输入:nums = [4,5,6,7,0,1,2]
输出:0
解释:原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。
示例 3:
输入:nums = [11,13,15,17]
输出:11
解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。
提示:
n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums
中的所有整数 互不相同nums
原来是一个升序排序的数组,并进行了1
至n
次旋转
思路:
二分查找,nums[mid]和nums[r]作比较,
nums[mid]<nums[r]:因为升序 r=mid ,不能等于mid-1 因为有情况可能把最小值放走。
nums[mid]>nums[r]: l=mid==r?mid:mid+1 可以为mid+1 因为nums[mid]>nums[r],不会放走最小值。
代码:
class Solution {
public int findMin(int[] nums) {
if(nums.length<2) return nums[0];
int l=0,r=nums.length-1;
while(l<r)
{
int mid=l+(r-l)/2;
if(nums[mid]<nums[r])//mid在后半段 且mid及mid前是最小值的所处区间(升序)
r=mid;
else //mid在前半段,且后半段是最小值所处区间
l=mid==r?mid:mid+1;
}
return nums[l];
}
}
154. 寻找旋转排序数组中的最小值 II
难度困难401
已知一个长度为 n
的数组,预先按照升序排列,经由 1
到 n
次 旋转 后,得到输入数组。例如,原数组 nums = [0,1,4,4,5,6,7]
在变化后可能得到:
- 若旋转
4
次,则可以得到[4,5,6,7,0,1,4]
- 若旋转
7
次,则可以得到[0,1,4,4,5,6,7]
注意,数组 [a[0], a[1], a[2], ..., a[n-1]]
旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]
。
给你一个可能存在 重复 元素值的数组 nums
,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
示例 1:
输入:nums = [1,3,5]
输出:1
示例 2:
输入:nums = [2,2,2,0,1]
输出:0
提示:
n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums
原来是一个升序排序的数组,并进行了1
至n
次旋转
进阶:
- 这道题是 寻找旋转排序数组中的最小值 的延伸题目。
- 允许重复会影响算法的时间复杂度吗?会如何影响,为什么?
思路:
1. 当 nums[mid] > nums[right]时,mid 一定在第 1 个排序数组中,ii 一定满足 mid < i <= right,因此执行 left = mid + 1;
2. 当 nums[mid] < nums[right] 时,mid 一定在第 2 个排序数组中,ii 一定满足 left < i <= mid,因此执行 right = mid;
3. **当 nums[mid] == nums[right] 时,是此题对比 153题 的难点(原因是此题中数组的元素可重复,难以判断分界点 ii 指针区间);r--**
例如 [1, 0, 1, 1, 1][1,0,1,1,1] 和 [1, 1, 1, 0, 1][1,1,1,0,1] ,在 left = 0, right = 4, mid = 2 时,无法判断 mid在哪个排序数组中。
4. 我们采用 right = right - 1 解决此问题,证明:
此操作不会使数组越界:因为迭代条件保证了 right > left >= 0;
此操作不会使最小值丢失:假设 nums[right], nums[right] 是最小值,有两种情况:
- 若 nums[right] 是唯一最小值:那就不可能满足判断条件 nums[mid] == nums[right],因为 mid > right(left != right 且 mid = (left + right) // 2 向下取整);
- 若 nums[right]不是唯一最小值,由于 mid < right 而 nums[mid] == nums[right],即还有最小值存在于 [left, right - 1] 区间,因此不会丢失最小值。
代码:
class Solution {
// O(logn) 可能会退化成O(n)
public int findMin(int[] nums) {
if(nums.length==1) return nums[0];
int l=0,r=nums.length-1;
while(l<r)
{
int mid=l+(r-l)/2;
//System.out.println(l+" "+r+" "+mid);
if(nums[mid]<nums[r])
r=mid;
else if(nums[mid]==nums[r])
r--;
else
l=mid==r?mid:mid+1;
}
return nums[l];
}
}