[剑指offer-11]旋转数组的最小数字

题目描述：
把一个数组最开始的若干个元素搬到数组的末尾， 我们称之数组的旋转。
输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3, 4, 5, 1, 2｝为｛l ,2, 3, 4, 5}的一个旋转，该数组的最小值为1。
思路：
用二分法来查找可提高速度，分为三种情况：

• 典型输入
• 单调升序数组，旋转0个元素，也就是单调升序数组本身
• 第一个数字和最后一个数字重复和中间数字重复，二分法无效。采用顺序法。
  例如：数组{1,0,1,1,1}和数组{1,1,1,0,1}

代码（java 版）：

public class Test11 {
    /**
     * 把一个数组最开始的若干个元素搬到数组的末尾， 我们称之数组的旋转。
     * 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
     * 例如数组{3, 4, 5, 1, 2｝为｛l ,2, 3, 4, 5}的一个旋转，该数组的最小值为
     */
    public static int getMin(int[] numbers) {
        if (numbers == null || numbers.length <= 0) {
            throw new RuntimeException("错误输入");
        }

        //定义开始处理的第一个指针
        int index1 = 0;
        //定义开始处理的第二个指针
        int index2 = numbers.length - 1;
        //设置处理的初始值
        int mid = index1;
        while (numbers[index1] >= numbers[index2]) {
            //第一个数字总是大于或者等于最后一个数字

            //循环结束条件
            if (index2 - index1 == 1) {
                mid = index2;
                break;
            }

            mid = (index1 + index2) / 2;

            //如果三个数都相等，则二分法无效，需要进行顺序处理，从头到尾找最小的元素
            if (numbers[index1] == numbers[index2] && numbers[mid] == numbers[index1]) {
                return minInorder(numbers, index1, index2);
            }

            if (numbers[index1] <= numbers[mid]) {
                //中间的数字在第一个数组中，我们要找的最小的数字应该在中间数字的后面
                index1 = mid;
            } else if (numbers[mid] <= numbers[index2]) {
                //最小的元素位于中间数的前面
                index2 = mid;
            }
        }

        return numbers[mid];

    }

    /**
     * 按顺序法找数组中的最小值
     *
     * @param numbers
     * @param index1
     * @param index2
     * @return
     */
    public static int minInorder(int[] numbers, int index1, int index2) {

        int result = numbers[index1];

        for (int i = index1 + 1; i <= index2; i++) {
            if (result >= numbers[i]) {
                result = numbers[i];
            }
        }
        return result;

    }


    public static void main(String[] args) {
        // 1.输入NULL
//        System.out.println(getMin(null));
        //2. 典型输入，单调升序的数组的一个旋转
        int[] array1 = {3, 4, 5, 1, 2};
        System.out.println(getMin(array1));
        // 3.有重复数字，但重复的数字不是第一个数字和最后一个数字
        int[] array2 = {3, 4, 5, 1, 2, 2};
        System.out.println(getMin(array2));

        //4. 有重复数字，并且重复的数字刚好的最小的数字
        int[] array3 = {3, 4, 5, 1, 1, 2};
        System.out.println(getMin(array3));

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

        int[] array5 = {1,1,1,0,1};
        System.out.println(getMin(array5));

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

        // 数组中只有一个数字
        int[] array7 = {2};
        System.out.println(getMin(array7));

        // 数组中数字都相同
        int[] array8 = {7,7,7,7,7,7};
        System.out.println(getMin(array8));

    }
}

测试结果

1
1
1
0
0
1
2
7

代码（python 版）：

# -*-coding:utf-8-*-
class Numbers:
    def getMax(self,numbers):
        lenArr = len(numbers)
        if not numbers or lenArr <= 0:
            return None

        index1 = 0
        index2 = lenArr-1
        mid = index1

        while numbers[index1] >= numbers[index2]:
            if index2-index1 == 1:
                mid = index2
                break
            mid = (index1+index2)/2
            # 如果index1,index2和mid的值相同，改用顺序法查找
            if numbers[index1]==numbers[index2] and numbers[index1] == numbers[mid]:
                return self.getMinOrder(numbers,index1,index2)
            if numbers[mid] >= numbers[index1]:
                index1 = mid
            elif numbers[mid] <= numbers[index2]:
                index2 = mid


        return numbers[mid]

    def getMinOrder(self,list, index1, index2):
        result = list[index1]
        for i in xrange(index1+1,index2+1):
            if result >= list[i]:
                result = list[i]
        return result

numbers = Numbers();
list = [3,4,5,1,2]
print numbers.getMax(list)

list2 = [3,4,5,1,2,2]
print numbers.getMax(list2)

list3 = [3,4,5,1,1,2]
print numbers.getMax(list3)

list4 = [1,0,1,1,1]
print numbers.getMax(list4)

list5 = [1,1,1,0,1]
print numbers.getMax(list5)

list6 = [1,2,3,4,5,5]
print numbers.getMax(list6)

list7 = [2]
print numbers.getMax(list7)

list8 = [7,7,7,7,7,7]
print numbers.getMax(list8)

print numbers.getMax([])

测试结果

1
1
1
0
0
1
2
7
None