剑指Offer——题11（旋转数组的最小数)

【题目】：

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。

【思路】：

旋转后的数组可以划分为两个排序的子数组，并且前面数组的元素大于等于后面数组的元素。最小的元素刚好是这两个数组的分界点，所以采用二分查找法。

　　特殊情况：

　　1.递增排序数组的本身是自己的旋转，则最小数字是第一个数字

　　2.中间数字与首尾数字大小相等，如{1,0,1,1,1,1}和{1,1,1,1,0,1}，无法采用二分法，只能顺序查找。

 

java code:

package com.offer.offer11;

/**
 * @author zth
 * @Date 2019-08-08 15:05
 */
public class Min {
    public static int minNumberInRotateArray(int [] array) {
        if (null == array || array.length <= 0){
            return 0;
        }
        int left = 0;
        int right = array.length-1;

        /**
         * 数组的前 0 个元素旋转即数组为自增数组
         * 递增排序数组是自己的旋转
         */
        if (array[left] < array[right]){
            return array[0];
        }
        int mid = left;
        while (left < right){

            if (right - left==1){
                mid = right;
                break;
            }
            mid = (right + left)/2;
            /**
             * 如果三个指针所指位置为元素相等，则只能顺序查找，如下情况：
             * 1 0  1 1 1
             * 1 1 1 0 1
             */

            if (array[mid] == array[left] && array[mid]==array[right] ){
                return getMinInOrder(array,left,right);
            }
            if (array[mid] >= array[right]){
                left = mid;
            }else {
                right = mid;
            }
        }
        return array[mid];
    }

    private static int getMinInOrder(int array[],int left,int right){
        int min = array[left];
        for (int i = left+1; i <= right; i++) {
            if (array[i] < min){
                min =array[i];
            }
        }
        return min;
    }

    public static void main(String[] args){
        int[] array1 = { 1, 2, 3, 4, 5, 6 };
        int[] array2 = { 3,4,5,1,2 };
        int[] array3 = { 2};
        int[] array4 = null;

       System.out.println( minNumberInRotateArray(array2));
    }
}