剑指offer-求旋转数组的最大最小数值

/*******************************************************************
Copyright(c) 2016, Harry He
All rights reserved.
*******************************************************************/
// 作者:TyroneLi
//

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

#include <iostream>
#include <cstdio>

int minInOrder(int arr[], int index_1, int index_2)
{
    int result = *(arr + index_1);
    for(int i = index_1 + 1; i <= index_2; ++i)
    {
        if(*(arr + i) < result)
            result = *(arr + i);
    }
    return result;
}

int maxInOrder(int arr[], int index_1, int index_2)
{
    int result = *(arr + index_1);
    for(int i = index_1 + 1; i <= index_2; ++i)
    {
        if(*(arr + i) > result)
            result = *(arr + i);
    }
    return result;
}

int rotatedMin(int arr[], int length)
{
    if(arr == nullptr || length <= 0)
    {
        std::cout << "arrar error!" << std::endl;
        exit(1);
    }

    int index_1 = 0;
    int index_2 = length - 1;
    int midIndex = index_1;
    while(*(arr + index_1) >= *(arr + index_2))
    {
        if(index_2 - index_1 == 1)
        {
            midIndex = index_2;
            break;
        }
        midIndex = (index_1 + index_2) / 2;
        if(*(arr + midIndex) == *(arr + index_1) && *(arr + midIndex) == *(arr + index_2))
            return minInOrder(arr, index_1, index_2);
        if(*(arr + midIndex) >= *(arr + index_1))
            index_1 = midIndex;
        if(*(arr + midIndex) <= *(arr + index_2))
            index_2 = midIndex;
    }
    return *(arr + midIndex);
}

int rotatedMax(int arr[], int length)
{
    if(arr == nullptr || length <= 0)
    {
        std::cout << "arrar error!" << std::endl;
        exit(1);
    }

    int index_1 = 0;
    int index_2 = length - 1;
    int midIndex = index_2;
    while(*(arr + index_1) >= *(arr + index_2))
    {
        if(index_2 - index_1 == 1)
        {
            midIndex = index_1;
            break;
        }
        midIndex = (index_1 + index_2) / 2;
        if(*(arr + midIndex) == *(arr + index_1) && *(arr + midIndex) == *(arr + index_2))
            return maxInOrder(arr, index_1, index_2);
        if(*(arr + midIndex) >= *(arr + index_1))
            index_1 = midIndex;
        if(*(arr + midIndex) <= *(arr + index_2))
            index_2 = midIndex;
    }
    return *(arr + midIndex);
}

void test_rotatedMin()
{
    int arr[] = {3,4,5,1,2};
    int result = rotatedMin(arr, 5);
    std::cout << "found min value = " << result << std::endl;
    result = rotatedMax(arr, 5);
    std::cout << "found max value = " << result << std::endl;

    int arr_2[] = {1,0,1,1,1};
    result = rotatedMin(arr_2, 5);
    std::cout << "found min value = " << result << std::endl;
    result = rotatedMax(arr_2, 5);
    std::cout << "found max value = " << result << std::endl;

    int arr_3[] = {1,1,1,0,1};
    result = rotatedMin(arr_3, 5);
    std::cout << "found min value = " << result << std::endl;
    result = rotatedMax(arr_3, 5);
    std::cout << "found max value = " << result << std::endl;

    int arr_4[] = {3, 6, 6, 9, 0};
    result = rotatedMin(arr_4, 5);
    std::cout << "found min value = " << result << std::endl;
    result = rotatedMax(arr_4, 5);
    std::cout << "found max value = " << result << std::endl;

    int arr_5[] = {3, 6, 6, 9, 10};
    result = rotatedMin(arr_5, 5);
    std::cout << "found min value = " << result << std::endl;
    result = rotatedMax(arr_5, 5);
    std::cout << "found max value = " << result << std::endl;
}

int main(int argc, char**argv)
{

    test_rotatedMin();

    return 0;
}