每日一题之 寻找旋转排序数组中的最小值系列

题目1：
已知一个长度为 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 次得到输入数组。

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

题目2：
已知一个长度为 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

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

解题思路：
方法1：
二分查找

1. 需要注意的是，不管旋转多少次，都会存在两个分离的单调区间。
2. 寻找最小值时，我们可以找到最小值之前的最大值，找到后向后偏移一位即可 （需要注意单调递增的序列需要取nums首位）
3. mid = r + l + 1 >> 1;为何要偏移一位？防止死循环。
4. 题目2可能出现重复元素，需要先进行恢复二段性的处理。

//题目1
class Solution {
    public int findMin(int[] nums) {
        int n = nums.length;
        //special
        if (n == 0) {
            return 0;
        }
        //normal
        int l = 0; 
        int r = n - 1;
        while (l < r) {

            int mid = r + l + 1 >> 1;
            //最后一个 大于等于 nums[0]的值，就是最大值
            if (nums[mid] >= nums[0]) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        //如果r为最大值，则取第一个
        return r + 1 < n? nums[r + 1] : nums[0];
    }
}

//题目2
class Solution {
    public int findMin(int[] nums) {
        int n = nums.length;
        //special
        if (n == 0) {
            return 0;
        }

        //normal
        int l = 0;
        int r = n - 1;
        //恢复二段性 保证前后两段性质不同
        while (l < r && nums[r] == nums[0]) r--;
        while (l < r) {
            int mid = r + l + 1 >> 1;

            //寻找最大值，并继续偏移
            if (nums[mid] >= nums[0]) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        // 单调递增场景
        return r+1<n?nums[r + 1]:nums[0];
    }
}