剑指offer_JZ6_旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

示例：

输入：[3,4,5,1,2]
返回值：1

思路1：

1.数组为空，返回0
2.部分旋转，如：【1，2，3，4，6，8，9】 部分旋转后：【4，6，8，9，1，2，3】
3.整体旋转，如：【1，2，3，4，6，8，9】

import java.util.ArrayList;
public class Solution {
    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]; //整体旋转，数组非递减
    }
}

结果：

思路2：

采用二分法
将旋转数组对半分可以得到一个包含最小元素的新旋转数组，以及一个非递减排序的数组。如【2，3，4，1】 拆分为【2，3】和【4，1】。新的旋转数组的长度是原数组的一半，从而将问题规模减少了一半，这种折半性质的算法的时间复杂度为 O(log2N)。
需要考虑三种情况：
1.array[mid] > array[high]
说明low – mid 区间都是非递减的，如：【3，4，5，1，2】，从而low = mid + 1; 问题规模缩减为原来的一半.
2.array[mid] == array[high]
如：【1，1，1，0，1】或【1，0，1，1，1】，此时不确定新的旋转数组在mid的左边还是右边，只能一个一个试，high = high - 1; 或 low = low + 1;
3.array[mid] < array[high]
如【1，0，1，1】或【2，3，4，5】，此时mid右边一定是非递减的，新的旋转数组一定在mid的左边
high = mid;

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length == 0){
            return 0;
        }
        int low = 0,high = array.length-1,mid;
        while(low < high){
            mid = (low + high) / 2;
            if(array[mid] > array[high]){
                low = mid + 1;
            }else if(array[mid] == array[high]){
                high = high - 1;
            }else{
                high = mid;
            }
        }
        return array[low];
    }
}