剑指offer——面试题11：旋转数组的最小数字

 #include"iostream"
 using namespace std;

 int GetMinNumber(int *data,int len)
 {
     int left=,right=len-,mid;

     while(left<right-)
     {
         mid=(left+right)/;
         if(data[mid]>=data[left])
             left=mid;
         else if(data[mid]<data[right])
             right=mid;
     }
     return data[right];
 }

 void Test1()
 {
     cout<<"Test1:";
     int data[]={,,,,};
     if(GetMinNumber(data,)==)
         cout<<"passed."<<endl;
     else
         cout<<"failed."<<endl;
 }

 void Test2()
 {
     cout<<"Test2:";
     int data[]={,,,,,};
     if(GetMinNumber(data,)==)
         cout<<"passed."<<endl;
     else
         cout<<"failed."<<endl;
 }

 void Test3()
 {
     cout<<"Test3:";
     int data[]={,};
     if(GetMinNumber(data,)==)
         cout<<"passed."<<endl;
     else
         cout<<"failed."<<endl;
 }

 int main()
 {
     Test1();
     Test2();
     Test3();
     return ;
 }

官方答案：

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

 #include <cstdio>
 #include <exception>

 int MinInOrder(int* numbers, int index1, int index2);

 int Min(int* numbers, int length)
 {
     if(numbers == nullptr || length <= )
         throw new std::exception("Invalid parameters");

     int index1 = ;
     int index2 = length - ;
     int indexMid = index1;
     while(numbers[index1] >= numbers[index2])
     {
         // 如果index1和index2指向相邻的两个数，
         // 则index1指向第一个递增子数组的最后一个数字，
         // index2指向第二个子数组的第一个数字，也就是数组中的最小数字
         if(index2 - index1 == )
         {
             indexMid = index2;
             break;
         }

         // 如果下标为index1、index2和indexMid指向的三个数字相等，
         // 则只能顺序查找
         indexMid = (index1 + index2) / ;
         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];
 }

 int MinInOrder(int* numbers, int index1, int index2)
 {
     int result = numbers[index1];
     for(int i = index1 + ; i <= index2; ++i)
     {
         if(result > numbers[i])
             result = numbers[i];
     }

     return result;
 }

 // ====================测试代码====================
 void Test(int* numbers, int length, int expected)
 {
     int result = ;
     try
     {
         result = Min(numbers, length);

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

         if(result == expected)
             printf("\tpassed\n");
         else
             printf("\tfailed\n");
     }
     catch (...)
     {
         if(numbers == nullptr)
             printf("Test passed.\n");
         else
             printf("Test failed.\n");
     }
 }

 int main(int argc, char* argv[])
 {
     // 典型输入，单调升序的数组的一个旋转
     int array1[] = { , , , ,  };
     Test(array1, sizeof(array1) / sizeof(int), );

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

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

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

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

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

     // 输入nullptr
     Test(nullptr, , );

     return ;
 }

与官方答案相比较，我少考虑了很多种特殊情况，相差甚远。