据说这是一道腾讯的面试题。

描述：

原意：

 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
 
例如，数组[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

人话：

题目花里胡哨的，其实一句话说完，就是找到这个数组的最小值。

思路：

• 暴力法

暴力法很简单，遍历数组，选择一个元素，再和每一个元素进行比较。

但是这种时间复杂度是 O(n)

• 二分查找

题目说到数组是递增排序的，既然是‘有序’的，那可以使用二分查找。

二分查找的核心：选择一个中间数，依次比较即可。

时间复杂度是 O(logn)

public class 腾讯旋转数 {
    public static void main(String[] args) {
        int[] nums = new int[]{3, 4, 5, 1, 2};
        System.out.println(minArray(nums));

    }

    public static int minArray(int[] numbers) {
        //下标
        int start = 0;
        int end = numbers.length - 1;

        /**
         *           mid到end ，
         *         1. 递增，mid<end，肯定在左边    12345
         *         2. 递减，mid>end，肯定在右边    34512
         *         3. ==的时候，mid = end , 不能确定    12223 ， 32221
         */
        while (start < end) {
            //中间的数
            int mid = (start + end) / 2;
            //如果最后的数大于中间的数，那么这是个递增的数，那么最小的数肯定是在左边
            if (numbers[mid] < numbers[end]) {
                //
                end = mid;
            }
            if (numbers[mid] > numbers[end]) {
                start = mid + 1; //要加 1 噢
            }
            //没办法了，只能暴力获取了
            if (numbers[mid] == numbers[end]) {
                int result = getMinResult(start, end, numbers);
                return result;
            }
        }
        return numbers[start];
    }

    /**
     * 获取数组最小的值
     * @param start
     * @param end
     * @param nums
     * @return
     */
    public static int getMinResult(int start, int end, int[] nums) {
        int min = nums[start];
        for (; start < end; start++) {
            if (min > nums[start]) {
                min = nums[start];
            }
        }
        return min;
    }
}