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

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

用二分查找的方式来查找数组的最小值，这个值是存在于最大值到最小值的转折中，一个指针指向第一个升序子数组的第一个元素，第二个指针指向第二个升序子数组的最后一个元素，确定数组中间的元素，如果是比第一个指针的元素大，则表示中间指针存在第一个升序子序列中，将第一个指针指向中间指针指向的元素，如果中间元素比第二个指针指向的元素小，则表明中间元素存在第二个子序列中，则将第二个指针指向中间元素。

 

测试用例：

1）功能测试（输入的数组是升序排序数组的一个旋转，数组中有重复数字或者没有重复数字）。

2）边界值测试（输入的数组是一个升序排序的数组，只包含一个数字的数组）。

3）特殊输入测试（输入null指针）。

实现代码：

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);
    }
}

输出结果：

The resource sequence is:

[3, 4, 5, 6, 0, 1, 2]

The minimum is 0, Passed!

The resource sequence is:

[3, 4, 5, 1, 1, 2]

The minimum is 1, Passed!

The resource sequence is:

[3, 4, 5, 1, 2, 2]

The minimum is 1, Passed!

The resource sequence is:

[1, 0, 1, 1, 1]

The minimum is 0, Passed!

The resource sequence is:

[1, 2, 3, 4, 5]

The minimum is 1, Passed!

The resource sequence is:

[2]

The minimum is 2, Passed!

The resource sequence is:

null