原文链接: https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array
英文原文
Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:
[4,5,6,7,0,1,2]if it was rotated4times.[0,1,2,4,5,6,7]if it was rotated7times.
Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
Given the sorted rotated array nums of unique elements, return the minimum element of this array.
You must write an algorithm that runs in O(log n) time.
Example 1:
Input: nums = [3,4,5,1,2] Output: 1 Explanation: The original array was [1,2,3,4,5] rotated 3 times.
Example 2:
Input: nums = [4,5,6,7,0,1,2] Output: 0 Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
Example 3:
Input: nums = [11,13,15,17] Output: 11 Explanation: The original array was [11,13,15,17] and it was rotated 4 times.
Constraints:
n == nums.length1 <= n <= 5000-5000 <= nums[i] <= 5000- All the integers of
numsare unique. numsis sorted and rotated between1andntimes.
中文题目
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.length1 <= n <= 5000-5000 <= nums[i] <= 5000nums中的所有整数 互不相同nums原来是一个升序排序的数组，并进行了1至n次旋转
通过代码
高赞题解
这道寻找最小值的题目可以用二分查找法来解决，时间复杂度为O(logN)，空间复杂度为O(1)。
看一下代码：
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) { left = mid + 1; } else { right = mid; } } return nums[left]; } };
[]class Solution { public int findMin(int[] nums) { int left = 0; int right = nums.length - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) { left = mid + 1; } else { right = mid; } } return nums[left]; } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 while left < right: mid = (left + right) >> 1 if nums[mid] > nums[right]: left = mid + 1 else: right = mid return nums[left]
[]var findMin = function(nums) { var left = 0; var right = nums.length - 1; while (left < right) { var mid = (left + right) >> 1; if (nums[mid] > nums[right]) { left = mid + 1; } else { right = mid; } } return nums[left]; };
首先说一下主要思路：
单调递增的序列：
*
*
*
*
*
做了旋转：
*
*
*
*
*
用二分法查找，需要始终将目标值（这里是最小值）套住，并不断收缩左边界或右边界。
左、中、右三个位置的值相比较，有以下几种情况：
- 左值 < 中值, 中值 < 右值 ：没有旋转，最小值在最左边，可以收缩右边界
右
中
左
左值 > 中值, 中值 < 右值 ：有旋转，最小值在左半边，可以收缩右边界
左 右 中
左值 < 中值, 中值 > 右值 ：有旋转，最小值在右半边，可以收缩左边界
中 左 右
左值 > 中值, 中值 > 右值 ：单调递减，不可能出现
左 中 右
分析前面三种可能的情况，会发现情况1、2是一类，情况3是另一类。
如果中值 < 右值，则最小值在左半边，可以收缩右边界。
如果中值 > 右值，则最小值在右半边，可以收缩左边界。
通过比较中值与右值，可以确定最小值的位置范围，从而决定边界收缩的方向。
而情况1与情况3都是左值 < 中值，但是最小值位置范围却不同，这说明，如果只比较左值与中值，不能确定最小值的位置范围。
所以我们需要通过比较中值与右值来确定最小值的位置范围，进而确定边界收缩的方向。
接着分析解法里的一些问题：
首先是while循环里的细节问题。
这里的循环不变式是left < right, 并且要保证左闭右开区间里面始终套住最小值。
中间位置的计算：mid = left + (right - left) / 2
这里整数除法是向下取整的地板除，mid更靠近left，
再结合while循环的条件left < right，
可以知道left <= mid，mid < right，
即在while循环内，mid始终小于right。
因此在while循环内，nums[mid]要么大于要么小于nums[right]，不会等于。
这样else {right = mid;}这句判断可以改为更精确的
else if (nums[mid] < nums[right]) {right = mid;}。
再分析一下while循环退出的条件。
如果输入数组只有一个数，左右边界位置重合，left == right，不会进入while循环，直接输出。
如果输入数组多于一个数，循环到最后，会只剩两个数，nums[left] == nums[mid]，以及nums[right]，这里的位置left == mid == right - 1。
如果nums[left] == nums[mid] > nums[right]，则左边大、右边小，
需要执行left = mid + 1，使得left == right，左右边界位置重合，循环结束，nums[left]与nums[right]都保存了最小值。
如果nums[left] == nums[mid] < nums[right]，则左边小、右边大，
会执行right = mid，使得left == right，左右边界位置重合，循环结束，nums[left]、nums[mid]、nums[right]都保存了最小值。
细化了的代码：
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; /* 左闭右闭区间，如果用右开区间则不方便判断右值 */ while (left < right) { /* 循环不变式，如果left == right，则循环结束 */ int mid = left + (right - left) / 2; /* 地板除，mid更靠近left */ if (nums[mid] > nums[right]) { /* 中值 > 右值，最小值在右半边，收缩左边界 */ left = mid + 1; /* 因为中值 > 右值，中值肯定不是最小值，左边界可以跨过mid */ } else if (nums[mid] < nums[right]) { /* 明确中值 < 右值，最小值在左半边，收缩右边界 */ right = mid; /* 因为中值 < 右值，中值也可能是最小值，右边界只能取到mid处 */ } } return nums[left]; /* 循环结束，left == right，最小值输出nums[left]或nums[right]均可 */ } };
[]class Solution { public int findMin(int[] nums) { int left = 0; int right = nums.length - 1; /* 左闭右闭区间，如果用右开区间则不方便判断右值 */ while (left < right) { /* 循环不变式，如果left == right，则循环结束 */ int mid = left + (right - left) / 2; /* 地板除，mid更靠近left */ if (nums[mid] > nums[right]) { /* 中值 > 右值，最小值在右半边，收缩左边界 */ left = mid + 1; /* 因为中值 > 右值，中值肯定不是最小值，左边界可以跨过mid */ } else if (nums[mid] < nums[right]) { /* 明确中值 < 右值，最小值在左半边，收缩右边界 */ right = mid; /* 因为中值 < 右值，中值也可能是最小值，右边界只能取到mid处 */ } } return nums[left]; /* 循环结束，left == right，最小值输出nums[left]或nums[right]均可 */ } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 # 左闭右闭区间，如果用右开区间则不方便判断右值 while left < right: # 循环不变式，如果left == right，则循环结束 mid = (left + right) >> 1 # 地板除，mid更靠近left if nums[mid] > nums[right]: # 中值 > 右值，最小值在右半边，收缩左边界 left = mid + 1 # 因为中值 > 右值，中值肯定不是最小值，左边界可以跨过mid elif nums[mid] < nums[right]: # 明确中值 < 右值，最小值在左半边，收缩右边界 right = mid # 因为中值 < 右值，中值也可能是最小值，右边界只能取到mid处 return nums[left] # 循环结束，left == right，最小值输出nums[left]或nums[right]均可
再讨论一个问题：
为什么左右不对称？为什么比较mid与right而不比较mid与left？能不能通过比较mid与left来解决问题？
左右不对称的原因是：
这是循环前升序排列的数，左边的数小，右边的数大，而且我们要找的是最小值，肯定是偏向左找，所以左右不对称了。
为什么比较mid与right而不比较mid与left？
具体原因前面已经分析过了，简单讲就是因为我们找最小值，要偏向左找，目标值右边的情况会比较简单，容易区分，所以比较mid与right而不比较mid与left。
那么能不能通过比较mid与left来解决问题？
能，转换思路，不直接找最小值，而是先找最大值，最大值偏右，可以通过比较mid与left来找到最大值，最大值向右移动一位就是最小值了（需要考虑最大值在最右边的情况，右移一位后对数组长度取余）。
以下是先找最大值的代码，可以与前面找最小值的比较：
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; while (left < right) { int mid = left + (right - left + 1) / 2; /* 先加一再除，mid更靠近右边的right */ if (nums[left] < nums[mid]) { left = mid; /* 向右移动左边界 */ } else if (nums[left] > nums[mid]) { right = mid - 1; /* 向左移动右边界 */ } } return nums[(right + 1) % nums.size()]; /* 最大值向右移动一位就是最小值了（需要考虑最大值在最右边的情况，右移一位后对数组长度取余） */ } };
[]class Solution { public int findMin(int[] nums) { int left = 0; int right = nums.length - 1; while (left < right) { int mid = left + (right - left + 1) / 2; /* 先加一再除，mid更靠近右边的right */ if (nums[left] < nums[mid]) { left = mid; /* 向右移动左边界 */ } else if (nums[left] > nums[mid]) { right = mid - 1; /* 向左移动右边界 */ } } return nums[(right + 1) % nums.length]; /* 最大值向右移动一位就是最小值了（需要考虑最大值在最右边的情况，右移一位后对数组长度取余） */ } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 while left < right: mid = (left + right + 1) >> 1 # 先加一再除，mid更靠近右边的right if nums[left] < nums[mid]: left = mid # 向右移动左边界 elif nums[left] > nums[mid]: right = mid - 1 # 向左移动右边界 return nums[(right + 1) % len(nums)] # 最大值向右移动一位就是最小值了（需要考虑最大值在最右边的情况，右移一位后对数组长度取余）
使用left < right作while循环条件可以很方便推广到数组中有重复元素的情况，即154题：
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/
只需要在nums[mid] == nums[right]时挪动右边界就行：
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) { left = mid + 1; } else if (nums[mid] < nums[right]) { right = mid; } else { right--; } } return nums[left]; } };
[]class Solution { public int findMin(int[] nums) { int left = 0; int right = nums.length - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) { left = mid + 1; } else if (nums[mid] < nums[right]) { right = mid; } else { right--; } } return nums[left]; } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 while left < right: mid = (left + right) >> 1 if nums[mid] > nums[right]: left = mid + 1 elif nums[mid] < nums[right]: right = mid else: right -= 1 return nums[left]
初始条件是左闭右闭区间，right = nums.size() - 1，
那么能否将while循环的条件也选为左闭右闭区间left <= right？
可以的，代码如下：
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; while (left <= right) { // 循环的条件选为左闭右闭区间left <= right int mid = left + (right - left) / 2; if (nums[mid] >= nums[right]) { // 注意是当中值大于等于右值时， left = mid + 1; // 将左边界移动到中值的右边 } else { // 当中值小于右值时 right = mid; // 将右边界移动到中值处 } } return nums[right]; // 最小值返回nums[right] } };
[]class Solution { public int findMin(int[] nums) { int left = 0; int right = nums.length - 1; while (left <= right) { // 循环的条件选为左闭右闭区间left <= right int mid = left + (right - left) / 2; if (nums[mid] >= nums[right]) { // 注意是当中值大于等于右值时， left = mid + 1; // 将左边界移动到中值的右边 } else { // 当中值小于右值时 right = mid; // 将右边界移动到中值处 } } return nums[right]; // 最小值返回nums[right] } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 while left <= right: # 循环的条件选为左闭右闭区间left <= right mid = (left + right) >> 1 if nums[mid] >= nums[right]: # 注意是当中值大于等于右值时， left = mid + 1 # 将左边界移动到中值的右边 else: # 当中值小于右值时 right = mid # 将右边界移动到中值处 return nums[right] # 最小值返回nums[right]
这道题还有其它解法：
始终将nums[mid]与最右边界的数进行比较，相当于在每次裁剪区间之后始终将最右边的数附在新数组的最右边。
[]class Solution { public: int findMin(vector<int>& nums) { int right_boundary = nums[nums.size() - 1]; int left = 0; int right = nums.size() - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > right_boundary) { left = mid + 1; } else { right = mid; } } return nums[left]; } };
[]class Solution { public int findMin(int[] nums) { int right_boundary = nums[nums.length - 1]; int left = 0; int right = nums.length - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > right_boundary) { left = mid + 1; } else { right = mid; } } return nums[left]; } };
[]class Solution: def findMin(self, nums: List[int]) -> int: right_boundary = nums[- 1] left, right = 0, len(nums) - 1 while left < right: mid = (left + right) >> 1 if nums[mid] > right_boundary: left = mid + 1 else: right = mid return nums[left]
或者在处理了第一种情况之后，始终将nums[mid]与最左边界的数nums[0]进行比较，即相当于在每次裁剪区间之后始终将最左边的数附在新数组的最左边，再不断处理情况2及情况3。
[]class Solution { public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; if (nums[0] < nums[right]) return nums[left]; while (left < right) { int mid = left + (right - left) / 2; if (nums[0] > nums[mid]) right = mid; else left = mid + 1; } return nums[left]; } };
[]class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 if nums[left] < nums[right]: return nums[left] while left < right: mid = (left + right) >> 1 if nums[0] > nums[mid]: right = mid else: left = mid + 1 return nums[left]
统计信息
| 通过次数 | 提交次数 | AC比率 |
|---|---|---|
| 227505 | 400723 | 56.8% |
提交历史
| 提交时间 | 提交结果 | 执行时间 | 内存消耗 | 语言 |
|---|
相似题目
| 题目 | 难度 |
|---|---|
| 搜索旋转排序数组 | 中等 |
| 寻找旋转排序数组中的最小值 II | 困难 |
