【面试题8】旋转数组的最小数字

查找和排序在程序设计中是经常用到的算法。查找相对而言比较简单，不外乎顺序查找，二分查找，哈希表查找和二叉排序树查找。不管是用循环还是递归，面试官都希望应聘者能够信手拈来写出完整的二分查找代码，“面试题8：旋转数组的最小数字”和“面试题38：数字在排序数组中出现的次数”都可以用二分查找算法来解决。

提示：
如果要求在排序的数组（或者部分排序的数组）中查找一个数字或者统计某个数字出现的次数，我们都可以使用二分查找。

哈希表和二叉排序树查找的重点在于考查对应的数据结构而不是算法。
哈希表最主要的优点是我们利用它能够在O（1）时间查找某一元素，是效率最高的查找方式。但其缺点是需要额外的空间来实现哈希表。

排序比查找要复杂一些，面试频率较高的是插入排序，冒泡排序，归并排序，开速排序等不同算法的优劣。一定要对各种排序算法的特点烂熟于胸，能够从额外空间消耗，平均时间复杂度和最差时间复杂度等方面去比较它们的优缺点。
实现快速排序算法的关键在于先在数组中选择一个数字，接下来把数组中的数字分为两部分，比选择的数字小的数字移到数组的左边，比选择的数字大的移到数组的右边。这个函数实现如下：

int Partition(int data[],int length,int start,int end)
{
    if（data==NULL || length<=0 || start<0 || end>=length)
        throw new std::exception("Invalid parameters");

    int index=RandomInRange(start,end);
    Swap(&data[index],&data[end]);

    int small=start-1;
    for(index=start;index<end;++index）
    {
        if(data[index]<data[end])
        {
            ++small;
            if(small!=index)
                swap(&data[index],&data[small]);
        }
    }
    ++small;
    Swap(&data[small],&data[end]);
    return small;
}

函数RandomInRange用来生成一个在start和end之间的随机数，函数Swap的作业是用来交换两个数字。接下来可以用递归的思路分别对每次选中的数字左右两边排序。递归实现快速排序的参考代码如下：

void QuickSort(int data[],int length,int start,int end)
{
    if（start==end)
    return;
    int index=Partition(data,length,start,end);
    if(index>start)
        QuickSort(data,length,start,index-1);
    if（index<end)
        QuickSort(data,length,index+1,end);
}

在一个长度为n的数组排序，只需要把start=0，end=n-1，调用函数QuickSort即可。
在前面的代码中，函数Partition除了可以用在快速排序算法中，还可以用来实现在长度为n的数组中查找第k大的数字。

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

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

    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 MidInorder(numbers,index1,index2);

        if(numbers[indexMid]>=numbers[index1])
            index1=indexMid;
        else if（numbers[indexMid]<=numbers[index2])
            index2=indexMid;
    }
    return numbers[indexMid];
}

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