剑指 Offer 11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1

示例 2：

输入：[2,2,2,0,1]
输出：0

注意：本题与主站 154 题相同：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/

依旧是2分。

1. 习惯了从左边逼近，但具体做法需要结合数组的有序排列方式。
2. 如果写if..else,一定要把可能性写全

从左边逼近：

1. 如果left的<right的，则说明在[left,right]恒增，直接判断left最小
2. 如果left的<mid的，暗藏num[left]>number[right];故此完全表达是（numbers[right]<numbers[left]<numbers[mid]）,故右边有最小值
3. 如果left>mid时，左边有最小值，故令right=mid即可
4. 如果left=mid时，有：①左段（2，0，2，2）；②左段（2，2，2，3，3），那么可以对[left, mid]和[mid, right]分别二分，取最小；也可以对左段降重：left++；

class Solution {
    public int minArray(int[] numbers) {
        
        int left = 0;
        int right = numbers.length - 1;
        while(left<right){
            if(numbers[left]<numbers[right]) return numbers[left];
            int mid = left + (right-left) / 2;
            if(numbers[left]<numbers[mid]){
                //暗藏num[left]>number[right];
                //故此完全表达是
                //（numbers[right]<numbers[left]<numbers[mid]）,故右边有最小值
                left = mid;
            }else if(numbers[left]>numbers[mid]){
               //左边有最小值
               right = mid;
            }else{
                left ++;
            }
        }
        return numbers[right];
    }

}

或

class Solution {
    public int minArray(int[] numbers) {
        if(numbers[0]<numbers[numbers.length-1]) return numbers[0];
        return Two(numbers, 0, numbers.length-1);
    }
    public int Two(int [] numbers, int left, int right){
        while(left+1<right){
            if(numbers[left]<numbers[right]) return numbers[left];
            int mid = left + (right-left) / 2;
            if(numbers[mid] > numbers[left]){
                left = mid;
            }else if(numbers[mid] < numbers[left]){
                right = mid;
            }else{
                return Math.min(Two(numbers, left, mid), Two(numbers, mid, right));
            }
        }
        return numbers[right];
    }
}

从右边逼近的好处在于，右边段恒增!

class Solution {
    public int minArray(int[] numbers) {
        int left = 0;
        int right = numbers.length - 1;
        while(left<right){
            int mid = left + (right-left) / 2;
            if(numbers[mid]<numbers[right]){
                right = mid;
            }else if(numbers[mid]>numbers[right]){
                left = mid + 1;
            }else{
                right --;
            }
        }
        return numbers[left];
    }
}