【剑指offer】面试题8：旋转数组的最小数字

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

其实这里想了一个题外话，如果一个递增的数组，一直按照一个方向无论旋转多少次，都还是两个递增数组的拼接，如题目中的旋转就是{3，4，5}和{1,2}的拼接。证明的话，可以用归纳法。

就这道题来说，解法是二分查找；

int FindMin(int* a, int size) {
    int high = size - 1;
    int low = 0;
    int mid = (high + low) / 2;
    while(low < high - 1) {
        if (a[mid] > a[low]) {
            low = mid;
        } else {
            high = mid;
        }
        mid = (low + high) / 2;
    }

    return a[high];
}

貌似是可以了，但是想一下我们的逻辑，如果旋转之后和元素组一样，最小元素在第一个位置呢？
所以我们加上一句(13~14行）：

int FindMin(int* a, int size) {
    int high = size - 1;
    int low = 0;
    int mid = (high + low) / 2;
    while(low < high - 1) {
        if (a[mid] > a[low]) {
            low = mid;
        } else {
            high = mid;
        }
        mid = (low + high) / 2;
    }
    if (high == size - 1 && a[high] > a[low])
        return a[0];

    return a[high];
}

然后书上又说了一种情况，index为low,high,mid的三个元素大小都相等。这样就是说，我们无法判断最小元素在mid的左边还是右边；其实我们可以分两种情况，然后回溯，但是如果数据规模太大，可能会导致栈的深度很深，所以书上采用的一种思路是遇到这种情况直接遍历就好，也不是没有道理。

那么现在:

int FindMin(int* a, int size) {
    if (a == NULL || size <= 0) {
        cout << "Wrong input" << endl;
        return -1;
    }
    int high = size - 1;
    int low = 0;
    int mid = (high + low) / 2;
    while(low < high - 1) {
        if (a[low] == a[high] && a[mid] == a[low]) { //先判断特殊情况
            int minIndex = low;
            for (int i = low; i < high; i ++) {
                if (a[i] < a[minIndex]) minIndex = i;
            }
            return a[minIndex];
        }

        if (a[mid] > a[low]) {
            low = mid;
        } else {
            high = mid;
        }
        mid = (low + high) / 2;
    }
    if (high == size - 1 && a[high] > a[low])
        return a[0];

    return a[high];
}