8.旋转数组的最小数字

题目：
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

首先旋转数组的意思就是将前面的若干个元素切块放到后面，如：我们将一个数组{1,2,3,4,5}最开始的3个元素搬到数组的末尾，此时我们得到的切块为{1,2,3}，而原来的数组只剩下{4,5}，然后我们把切块{1,2,3}放到剩下数组{4,5}的后面，变成新的数组{4,5,1,2,3}.
当我们旋转了数组大小个(5个)的时候，数组将会和原来一样。如：对上面数组{1,2,3,4,5}的前5个元素旋转，切块为{1,2,3,4,5},剩下的数组为{ }，将切块放到数组变为新的数组{1,2,3,4,5}.

另外说一下非递减数组的意思：就是关键字递增序排列，但是并非单调递增（因为有重复的关键字）。如 1,2,3,3,4,5,8,8，….

对于这个题目，第一个方法就是简单遍历找到最小的数，然后返回。时间复杂度为O(n)

    public int minNumberInRotateArray(int [] array) {
        int min = 0;
        for (int i = 0; i <array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        return min;
    }

第二个方法就是对第一个方法进行了一下优化。
思想：数组其实分为两部分，前半部分是递增的数组，后半部分也是递增的数组; 前半部分的最后一个元素比后半部分的第一个元素大，利用这个特点在遍历的时候就行剪枝就好了。
时间复杂度为O(n)
代码：

   public int minNumberInRotateArray(int[] array) {
        if (array.length == 0)
            return 0;
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1])
                return array[i + 1];
        }
        return array[0];
    }

最后一种方法：
虽然整个数组是无序的，可是前半部分是递增的，后半部分也是递增的，采用二分法解答这个问题。最小元素就是前后部分的分界线。
mid=low+(high-low)/2
ps: (low+high)/2 这种计算方法可能会产生溢出。

需要考虑三种情况：
（1）array[mid]>array[high];
出现这种情况说明 low 指向前半部分，mid也是指向前半部分。
我们需要求的最小元素不在这里面，肯定在它的右边
如：{4,5,6,1,2,3}，6>3;
所以low=mid+1
（2）array[mid] < array[high];
出现这种情况说明 mid 指向 后半部分，high也是指向后半部分;
因为这是mid已经在后半部分，mid可能就是最小元素。
如：{4,5,1,2,3}，1<3:
所以high=mid
ps:如果high=mid-1,则会可能将最小元素抛在high后面。

（3）array[mid]==array[high];
出现这种情况说明不好判断最小元素在左边还是右边。只好从后边一个一个往前找。
如{1,1,0,1,1,1,1,1} 最小元素在左边
{1,1,1,1,0,1,1} 最小元素在右边
时间复杂度为O（logn）
代码：

    public int minNumberInRotateArray(int [] array) {

    int low = 0 ; int high = array.length - 1;
    while(low < high){
        int mid = low + (high - low) / 2;
        if(array[mid] > array[high]){
            low = mid + 1;
        }else if(array[mid] == array[high]){
            high = high - 1;
        }else{
            high = mid;
        }
    }
    return array[low];
}

如果用最小堆的话，那你建堆的时候就需要扫描一遍数组，那就已经是O(n)了，还是没有上面的方法快。