剑指Offer系列---(11)旋转数组的最小数字

1.题目描述：
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3，4，5，1，2}为{1，2，3，4，5}的一个旋转，该数组的最小值为。
2.分析：
我们用两个指针分别指向数组的第一个元素和最后一个元素。按照题目中的旋转规则，第一个元素应该是大于或者等于最后一个元素的（除了数组本身有序和有相同元素的特例之外）。
1）寻找数组的中间元素，如果该中间元素位于前面的递增子数组，那么它应该大于或者等于第一个指针指向的元素。此时数组中最小的元素应该位于该中间元素的后面。我们可以把第一个指针指向该中间元素，这样可以缩小寻找的范围。移动之后的第一个指针仍然位于前面的递增子数组之中。
2）如果中间元素位于后面的递增子数组，那么它应该小于或者等于第二个指针指向的元素。此时该数组中最小元素应该位于该中间元素的前面。我们可以把第二个指针指向该中间元素，这样也可以缩小寻找的范围，移动之后的第二个指针仍然位于后面的递增子数组之中。
3）按照上面的思路，重复新一轮查询，第一个指针总指向前面递增数组的元素，而第二个指针总指向后面递增数组的元素。最终第一个指针将指向前面子数组的最后一个元素，而第二个指针会指向后面子数组的第一个元素。也就是它们最终会指向两个相邻的元素，而第二个指针指向的刚好是最小的元素。这就是循环结束的条件。
3.源代码：

//  Copyright (c) 2015年 skewrain. All rights reserved.

#include <iostream>
#include <stdio.h>
using namespace std;

//求旋转数组的最小数字
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;
}

int Min(int *numbers,int length)
{
    if (numbers == NULL || length <= 0)
    {
        throw new std::exception();
    }
    int index1 = 0;
    int index2 = length-1;
    int indexMid = index1;
    while (numbers[index1] >= numbers[index2])
    {
        if(index2 - index1 == 1)
        {
            indexMid = index2;
            break;
        }
        indexMid = (index1 + index2)/2;
        //如果下标为index1、index2和indexMid指向的三个数字相等，则只能顺序查找
        if (numbers[index1] == numbers[index2] && numbers[indexMid] == numbers[index1])
        {
            return MinInOrder(numbers, index1, index2);
        }
        if(numbers[indexMid] >= numbers[index1])
            index1 = indexMid;
        else if(numbers[indexMid] <= numbers[index2])
            index2 = indexMid;
    }
    return numbers[indexMid];
}

void Test(int* numbers,int length,int expected)
{
    int result = 0;
    try {
        result = Min(numbers,length);
        for (int i=0; i<length; ++i) {
            printf("%d",numbers[i]);
        }
        
        if(result == expected)
            printf("\tpassed!\n");
        else
            printf("\nfailed!\n");
        
    } catch (...) {
        if (numbers == NULL) {
            printf("Test passed!\n");
        }
        else
            printf("Test failed!\n");
    }
}

int main(int argc,char *argv[]){

    //典型输入，单调升序的数组的一个旋转
    int array1[] = {3,4,5,1,2};
    Test(array1, sizeof(array1)/sizeof(int), 1);
    
    //有重复数字，并且重复的数字刚好是最小的数字
    int array2[] = {3,4,5,1,1,2};
    Test(array2, sizeof(array2)/sizeof(int), 1);
    
    //有重复数字，但重复的数字不是第一个数字和最后一个数字
    int array3[] = {3,4,5,1,2,2,};
    Test(array3, sizeof(array3)/sizeof(int), 1);
    
    //有重复数字，并且重复的数字刚好是第一个数字和最后一个数字
    int array4[] = {1,0,1,1,1};
    Test(array4, sizeof(array4)/sizeof(int), 0);
    
    //单调升序数组，旋转0个元素，也就是单调升序数组本身
    int array5[] = {1,2,3,4,5};
    Test(array5, sizeof(array5)/sizeof(int), 1);
    
    //数组中只有一个数字
    int array6[] = {2};
    Test(array6, sizeof(array6)/sizeof(int), 2);
    
    //输入NULL
    Test(array6, 0, 0);
    
    return 0;
}