旋转数组的最小数字

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

思路：
若直接用O（n）的顺序查找，显然不是最优解
因为经过旋转的数组也是由两个排好序的数组组成，要充分利用这一性质。
我们采取类似二分查找的方法，用p1指向开头元素，用p2指向最后元素，mid指向p1和p2中间的元素。
首先p1的元素应该大于p2的元素，否则则是没有发生旋转的情况，直接返回p1元素。
我们每次判断p1元素是不是小于mid元素，若小于，则移动p1到mid，进行一下次循环
若不小于，则移动p2到mid，直到p2和p1相邻，此时返回p2元素即可

需要注意的是，因为输入数组存在元素重复问题，所以当p1，p2，mid的元素相同时，只能进行顺序查找，例如test7（11101）的情况

int Min(int* numbers, int length)
{
	if (numbers == nullptr || length <= 0)
		throw new exception("无效的参数");
	
	if (length == 1)
		return numbers[0];
	if (numbers[0] < numbers[length - 1])//没有发生旋转的情况
		return numbers[0];
	int p1 = 0, p2 = length - 1;
	while (p2 - p1 != 1)
	{
		int mid = (p1 + p2) / 2;

		if (numbers[p1] == numbers[p2] && numbers[p1] == numbers[mid])//三个指针指向的值相等，只能顺序查找
		{
			int res = INT_MAX;
			for (int i = 0; i < length; ++i)
			{
				if (numbers[i] < res)
					res = numbers[i];
			}
			return res;
		}

		if (numbers[mid]> numbers[p1])
			p1 = mid;
		else
			p2 = mid;
	}
	return numbers[p2];
}

完整代码如下，包含测试代码

#include <iostream>
#include <exception>

using namespace std;

int Min(int* numbers, int length)
{
	if (numbers == nullptr || length <= 0)
		throw new exception("无效的参数");
	
	if (length == 1)
		return numbers[0];
	if (numbers[0] < numbers[length - 1])//没有发生旋转的情况
		return numbers[0];
	int p1 = 0, p2 = length - 1;
	while (p2 - p1 != 1)
	{
		int mid = (p1 + p2) / 2;

		if (numbers[p1] == numbers[p2] && numbers[p1] == numbers[mid])//三个指针指向的值相等，只能顺序查找
		{
			int res = INT_MAX;
			for (int i = 0; i < length; ++i)
			{
				if (numbers[i] < res)
					res = numbers[i];
			}
			return res;
		}

		if (numbers[mid]> numbers[p1])
			p1 = mid;
		else
			p2 = mid;
	}
	return numbers[p2];
}

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

		for (int i = 0; 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[] = { 3, 4, 5, 1, 2 };
	Test(array1, sizeof(array1) / sizeof(int), 1);

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

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

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

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

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

	int array7[] = { 1,1,1,0,1 };
	Test(array7, sizeof(array7) / sizeof(int), 0);

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

	system("pause");
	return 0;
}