旋转数组的最小数字

要求：时间限制：3秒 空间限制：32768K

问题描述：
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

方法一没达到要求，但运行正确
参考自剑指offer

/* 旋转数组的最小数字

*/
int orderFind(vector<int> array, int index1, int index2)
{
    int t = array[index1];
    for (int i = index1 + 1; i<index2; i++)
        if (t > array[i])
            t = array[i];
    return t;
}

bool isAllPositive(vector<int> array)
{
    for(int i=0; i<array.size(); i++)
        if(array[i] <= 0)
            return false;
    return true;
}

int minNumberInRotateArray_1(vector<int> rotateArray) {
    // 给出的所有元素都大于0，若数组大小为0，返回0
    if (rotateArray.size() == 0)
        return 0;
    else if (!isAllPositive(rotateArray))
        return 0;

    int p1 = 0;
    int p2 = rotateArray.size() - 1;
    int mid = p1;

    while (rotateArray[p1] >= rotateArray[p2])
    {
        if (p2 - p1 == 1)
        {
            mid = p2;
            break;
        }

        mid = (p1 + p2) / 2;
        if (rotateArray[mid] >= rotateArray[p1])
            p1 = mid;
        else if (rotateArray[mid] < rotateArray[p2])
            p2 = mid;

        if (rotateArray[mid] == rotateArray[p1] &&
            rotateArray[mid] == rotateArray[p2])
            return orderFind(rotateArray, p1, p2);
    }

    return rotateArray[mid];
}

方法二满足要求，且运行正确
参考自牛客网：https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba

int minNumberInRotateArray_2(vector<int > array) {
    int low = 0; int high = array.size() - 1;
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (array[mid] > array[high]) {
            low = mid + 1;
        }
        else if (array[mid] == array[high]) {
            high = high - 1;
        }
        else {
            high = mid;
        }
    }
    return array[low];
}

方法三，运行正常，满足要求
自己瞎琢磨

int minNumberInRotateArray_3(vector<int> rotateArray) {
    // 给出的所有元素都大于0，若数组大小为0，返回0
    if (rotateArray.size() == 0)
        return 0;

    int p1 = 0;
    int p2 = rotateArray.size() - 1;
    while (p1 < p2)
    {
        int mid = (p1 + p2) / 2;

        // 若有左边值小于右边值，说明从当前左边到右边是一个递增序列，左边即为最小
        if (rotateArray[p1] < rotateArray[p2])
            break;

        // 从左右分别判断，不等的时候采用二分索引，相等的时候向前/后移位，继续判断
        if (rotateArray[mid] > rotateArray[p1])
            p1 = mid;
        else if (rotateArray[mid] == rotateArray[p1])
            p1++;

        if (rotateArray[mid] < rotateArray[p2])
            p2 = mid;
        else if (rotateArray[mid] == rotateArray[p2])
            p2--;
    }
    return rotateArray[p1];
}
/*
运行时间：33ms

占用内存：504k
*/

测试：

int main()
{
    //vector<int > array = {5, 6, 7, 8, 1, 2, 4};
    vector<int > array = {2, 1, 2, 2, 2, 2};
    int result = minNumberInRotateArray_3(array);

    printf("%d", result);

    return 0;
}