【算法-LeetCode】153. 寻找旋转排序数组中的最小值（指针寻找临界点/断崖点；Array.sort）

153. 寻找旋转排序数组中的最小值 - 力扣（LeetCode）

发布：2021年9月27日17:01:05

问题描述及示例

已知一个长度为 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 次旋转

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我的题解

我的题解1（容易招打法：Array.sort）

我第一眼看到题目描述这么长，心里还是有点怕的，但是读了几遍后，发现……好像……也不是想象中的那么毫无思路，甚至只花了十秒都不到就写出来下面的解法：

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
  return nums.sort((a, b) => a - b)[0];
};


提交记录
150 / 150 个通过测试用例
状态：通过
执行用时：80 ms, 在所有 JavaScript 提交中击败了27.38%的用户
内存消耗：39.2 MB, 在所有 JavaScript 提交中击败了5.02%的用户
时间：2021/09/27 17:05

本来因为会因为超时而不通过的，结果没想到居然通过了……真搞不懂为啥非得搞那么多花里胡哨的东西，一看评论区，也差不多是这种感觉：

这道题的评论区画风😂

但是显然这种解法不是性能最优的，也不是题目想要考察的。所以这种解法虽然非常好理解，但是还是比较招打的，自然不能就此结束（内心OS：虽然我真的很想就这么pass……）。

我的题解2（断崖判断）

题目中说了 nums 中元素原本是升序的，经过若干次滚动后，其实 nums 中元素仍然可以看做是升序的，只不过是分成了两段的升序序列罢了。而这种解法就是找到这两段序列的分界点（或者说断崖点）：

寻找元素序列中的断崖

可惜的是，虽然思路是可行的，但是在在实现的过程中，由于自己的轻视和考虑不周，连续三次提交都是解答错误：

考虑不周的后果1

没有考虑到 nums 中没有断崖：

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
  let p = 0;
  while(nums[p] <= nums[p+1] && p < nums.length-1) {
    p++;
  }
  return Math.min(nums[p+1], nums[0]);
};


提交记录
执行结果：解答错误
通过测试用例：126 / 150
输入：[11,13,15,17]
输出：NaN
预期结果：11
时间：2021/09/27 17:29

考虑不周的后果2

没有及时更改 break 中的条件：

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
  let p = 0;
  while(p < nums.length-1) {
    if(nums[p] <= nums[p+1] || p === nums.length-2) {
      break;
    }
    p++;
  }
  return Math.min(nums[p+1], nums[0]);
};


提交记录
执行结果：解答错误
通过测试用例：21 / 150
输入：[3,4,5,1,2]
输出：3
预期结果：1
时间：2021/09/27 17:40

考虑不周的后果3

没有考虑到 nums 长度为 1 的情况：

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
  let p = 0;
  while(p < nums.length-1) {
    if(nums[p] > nums[p+1] || p === nums.length-2) {
      break;
    }
    p++;
  }
  return Math.min(nums[p+1], nums[0]);
};


提交记录
执行结果：解答错误
通过测试用例：126 / 150
输入：[1]
输出：NaN
预期结果：1
时间：2021/09/27 17:48

最后正解（毒打后的教训）

经过上面三次连续毒打后，我再一次提交，这次终于过了，泪目……😭

/**
 * @param {number[]} nums
 * @return {number}
 */
var findMin = function(nums) {
  if(nums.length === 1) {
    return nums[0];
  }
  let p = 0;
  while(p < nums.length-1) {
    if(nums[p] > nums[p+1] || p === nums.length-2) {
      break;
    }
    p++;
  }
  return Math.min(nums[p+1], nums[0]);
};


提交记录
150 / 150 个通过测试用例
状态：通过
执行用时：72 ms, 在所有 JavaScript 提交中击败了60.13%的用户
内存消耗：37.9 MB, 在所有 JavaScript 提交中击败了55.46%的用户
时间：2021/09/27 17:49	

可以看到，这种解法的性能比直接排序的解法还是高了一点的。至于本题中牵扯到的二分查找之类的思路，这里就不再研究了，可到下方【有关参考】中查看。

官方题解

更新：2021年7月29日18:43:21

因为我考虑到著作权归属问题，所以【官方题解】部分我不再粘贴具体的代码了，可到下方的链接中查看。

更新：2021年9月27日17:58:54

参考：寻找旋转排序数组中的最小值 - 寻找旋转排序数组中的最小值 - 力扣（LeetCode）

【更新结束】

有关参考

更新：2021年9月27日18:00:21
参考：写对二分查找不能靠模板，需要理解加练习 （附练习题） - 搜索插入位置 - 力扣（LeetCode）