把一個數組最開始的若干個元素搬到陣列的末尾，我們稱之為陣列的旋轉。

給你一個可能存在 重複 元素值的陣列 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];
    }
}