剑指offer之旋转数组的最小数字

此题是一个旋转数组如{3，4，5，1，2}这样的数组，用普通的算法自然能解出来，但二分法比较好（除非几种特殊情况）
还有就是异常的性质，先得，throw抛出异常，cache捕获，在这个程序中，调用了min函数，所以在min函数中throw,在text函数中cache，以后多写一写。
看代码吧

#include<iostream>
#include<exception>
using namespace std;
//此处必须声明函数MinInOrder 
int MinInOrder(int* array,int index1,int index2);

int min(int* array,int length)
{
    if(array == NULL || length <= 0)
       throw 1;
    int index1=0;
    int index2=length-1;
    int MidIndex=index1;
    while(array[index1]>=array[index2])
    {
        if(index2-index1==1)
        {
            MidIndex=index2;
            break;
        }
        MidIndex=(index1+index2)/2;
        if(array[index1]==array[index2]&&array[index1]==array[MidIndex])
            return MinInOrder(array,index1,index2);
        if(array[MidIndex]>=array[index1])
            index1=MidIndex;
        else if(array[MidIndex]<=array[index2])
            index2=MidIndex;
    }
    return array[MidIndex];
}

int MinInOrder(int* array,int index1,int index2)
{
    int result=array[index1];
    while(index1<=index2)
    {
        if(array[index1]<result)
            result=array[index1];
        index1++;
    }
    return result;
}
void Test(int* array ,int length ,int expected)
{
    int result = 0;
    try
    {
        result = min(array, length);

        for(int i = 0; i < length; ++i)
            printf("%d ", array[i]);

        if(result == expected)
            printf("\tpassed\n");
        else
            printf("\tfailed\n");
    }
    catch (...)
    {
        if(array == NULL)
            printf("Test passed.\n");
        else
            printf("Test failed.\n");
    }   
}
int main()
{
    // 典型输入，单调升序的数组的一个旋转
    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(NULL, 0, 0);

    return 0;
}