P66、面试题8：旋转数组的最小数字

package com.yyq;

import java.util.Arrays;

/**
 * Created by Administrator on 2015/9/10.
 */
public class FindMin {
    public static int findMin(int[] array){
        int len = 0;
        int i = 0;
        int j = 0;
        int mid = 0;
        try {
            if (array == null || array.equals(" ")) {
                throw new Exception("Invalid Parameters");
            }
            len = array.length;
            j = len - 1;
            while(array[i] >= array[j]){
                if (j - i == 1 || j == i){
                    mid = j;
                    break;
                }
                mid = ( i + j ) / 2;
                if (array[i] == array[j] && array[mid] == array[i])
                    return minInOrder(array,i,j);
                if (array[mid] >= array[i])
                    i = mid;
                else if (array[mid] <= array[j])
                    j = mid;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return array[mid];
    }
    public static int minInOrder(int[] array,int i, int j){
        int result = 0;
        for (int m = i + 1; m <= j; m++){
            if (result > array[m]){
                result = array[m];
            }
        }
        return result;
    }

    // ====================测试代码====================
    public static void Test(int[] numbers, int expected)
    {
        int result = 0;
        System.out.println("The resource sequence is:");
        System.out.println(Arrays.toString(numbers));
        if(numbers == null || numbers.equals(" ")) return;
        result = findMin(numbers);
        if(result == expected)
            System.out.println("The minimum is " + result + ", Passed!");
        else
            System.out.println("Fail!");
    }

    public static void main(String[] args){
        // 典型输入，单调升序的数组的一个旋转
        int array1[] = {3, 4, 5, 6, 0, 1, 2};
        Test(array1, 0);

        // 有重复数字，并且重复的数字刚好的最小的数字
        int array2[] = {3, 4, 5, 1, 1, 2};
        Test(array2, 1);

        // 有重复数字，但重复的数字不是第一个数字和最后一个数字
        int array3[] = {3, 4, 5, 1, 2, 2};
        Test(array3, 1);

        // 有重复的数字，并且重复的数字刚好是第一个数字和最后一个数字
        int array4[] = {1, 0, 1, 1, 1};
        Test(array4, 0);

        // 单调升序数组，旋转0个元素，也就是单调升序数组本身
        int array5[] = {1, 2, 3, 4, 5};
        Test(array5, 1);

        // 数组中只有一个数字
        int array6[] = {2};
        Test(array6, 2);

        // 输入NULL
        Test(null, 0);
    }
}