第九题。。

方法一：时间复杂度o(1)

package exercise09;

//把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
//给你一个可能存在重复元素值的数组numbers，它原来是一个升序排列的数组，
// 并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组[3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，
// 该数组的最小值为 1。
//注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

public class Soultion {
    public int minArray(int[] numbers) {
        int index = 0;
        for (int i = 0;i < numbers.length - 1;i++){
            if (numbers[i] > numbers[i+1]){
                index = i + 1;
                break;
            }
        }
        return numbers[index];
    }
}

方法二：二分法
时间复杂度o(logn)

class Solution {
    public int minArray(int[] numbers) {
  int left = 0;
        int right = numbers.length-1;
        while (left < right){
            //1、没有旋转，第一个数就是最小值
            if (numbers[left] < numbers[right]){
                return numbers[left];
            }
            int middle = left + (right - left)/2;//没有采用（right+left）/2可以避免溢出
            //2、middle一定处于上升1
            if (numbers[middle] > numbers[left]){
                left = middle + 1;
            }
            //3、middle一定处于上升2
            else if (numbers[middle] < numbers[left]){
                //不处于最小值位置
                if (numbers[middle - 1] <= numbers[middle]){
                    right = middle - 1;
                }else{
                    //处于最小值位置
                    return numbers[middle];
                }
            }
            //4、有可能落在1，也有可能落在2
            else if (numbers[middle] == numbers[left]){
                left ++;
            }
        }
        return numbers[left];
    }
}

看到有网友对最后一种情况，采用线性查找方式，个人感觉如果中间值落在上升1中（例如5，5，5，5（中间值），5，1, 5，5,），那么遍历需要至少遍历一半多（比较了5次（15）），而采用上面方法，是用中间值向后遍历（循环了2次，但由于上面的if，比较了8次（24））
如果中间值落在上升2中（5，5，1，5，5（中间值），5，5，5，5），遍历情况（比较2次），采用上述方法（循环2次，比较5次（（2-1）*4）+1）
浅显认识，本身自己还是执行的比线性查找少，但由于每次都要把上面if走一遍，所以好像没有线性查找快，但感觉也没差多少（不过我对复杂度掌握的不好，不知道分析的对不对）

int x = i;
for(int k = i + 1; k < j; k++) {
      if(numbers[k] < numbers[x]) x = k;
}
return numbers[x];