LeetCode每日一题： 154. 寻找旋转排序数组中的最小值 II

154. 寻找旋转排序数组中的最小值 II

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

题目

已知一个长度为 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 = [2,2,2,0,1]
输出：0

进阶：

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

思路

实话说这题还是比较简单的吧，熟练了二分基本上就不是很难了。就是最后处理边界值的时候注意一下就行了，二分的细节要求还是蛮高的。
这题也是在题目I的基础上去做的，所以做过I的话这题就蛮简单了，我甚至直接默写出来了代码= =。然后因为可能会有重复项，所以要考虑重复的情况，如果mid的值和right的值相同，就无法判断是否有序了。
解决方法一种是将 r-- 再重新计算判断，原因一个r-- 是不会越界的，

第二 r--不会丢掉最小值，因为首先r--的前提是nums[mid]==nums[right],

如果最小值在mid左边，r--肯定会导致mid变小，最终遍历到最小值；

如果最小值就是mid，那最小值肯定也会在[left，right-1]这个区间内，继续二分肯定也能得到最小值的。

另外当然也可以l++,也可以同时l++和r--看个人喜好了。注意mid的细节问题就行。

其实这种二分的原理我认为是每次将数组有序的部分删去，比如[5,6,1,2,3,4],每次将数组划分两半的时候总会有一部分是有序的，每次把有序的部分删掉，到最后肯定就只剩下[6,1]了，最后把1返回就行了。然后因为可能会重复，划分的时候可能就会导致看不出来是否有序，但r--相当于把重复的项去掉，那之后的数组肯定是能找到有序的部分了对吧。

可能还是因为我做过非常相似的题，所以这题基本上很容易吧= =。不过细节方面多少还是有点处理不当，也是错了两次才过的。嘛，追求极致吧，不要求完美，但要追求完美对吧。

然后的话允许重复的话明显是会影响二分查找的算法时间复杂度的，最坏情况下（1222222222这样的）会是O（n）的效率，因为数据基本上相等的情况下使用这种算法只能一个个遍历（r–）了，那还不如直接暴力来的好。

代码

// 二分查找的代码（越来越熟练了= =）
public static int findMin(int[] nums) {
    int n = nums.length;
    if (n == 1) return nums[0];

    int l = 0;
    int r = n - 1;

    while (l < r) {
        int mid = (r + l) / 2;

        if (nums[mid] == nums[r]) {
            r--;
        } else if (nums[mid] < nums[r]) {
            r = mid;
        } else {
            l = mid + 1;
        }

    }
    return nums[l];
}
// 先用暴力过的
public int findMin1(int[] nums) {
    int min = nums[0];
    for (int i = 0; i < nums.length; i++) {
        if (min > nums[i])
            min = nums[i];
    }
    return min;
}