旋转数组的最小数字查找

怀疑

什么是数组的旋转？
输入的旋转数组有什么特性？

题目

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

分析

这道题主要考察的是“查找最小的数”，只不过查找的数组比较特殊，是经过旋转之后的数组，原来的数组按照从小到大的顺序排序，后一个数总是大于等于前一个数。

这样的数组相当于两个从小到大排序的子数组，如果使用遍历的方法会消耗O(n)的时间复杂度，应该利用好这种数组的性质：
常规数组的性质：
一、 后一个子数组的第一个数就是最小的元素；
二、 使用二分法的话，用两个指针指向数组第一个位置和最后一个位置，首先可以分为几种情况：

1. 如果中间的数大于前面的数，那么中间的数属于前一个子数组；
2. 如果中间的数小于前面的数，那么中间的数属于后一个子数组；
3. 如果中间的数大于后面的数，说明中间的数属于前一个子数组；
4. 如果中间的数小于后面的数，说明中间的数属于后一个子数组。

使用1,2或者3,4就可以判断中间的数属于哪一个数组（后面我们假设使用1,2两个条件判断），然后判断：

如果中间的数在前一个数组，那么将第一个指针指向中间的数； 如果中间的数在后一个数组，那么将第二个指针指向中间的数。

因为这样可以让两个指针中间的结构不变，也就是说最小的数依然藏在两个指针之间。
如此循环下来，判断停止的条件是，两个指针挨在一起了，那么后一个指针所指的数就一定是整个数组中最小的数。

但是，考虑地全面一些，还存在一种情况，那就是这个数组中存在一些相等的数，这样判断就会存在一些问题，让两个指针无法和中间的数进行比较

因为两个指针所指的内容相等，不知道怎么判断中间的数属于前一个数组还是后一个数组

比如：

（三个1不知所措）

再比如：

（前后指针都指向3,中间的1不知所措）

这种情况出现的条件是前后两个指针所指的内容相同，这种情况二分法就失效了，只能使用遍历的方法进行查找。

如果前后两个指针的数不相同，但是第一个数和中间的数相同，那么中间数一定属于前一个子数组
不可能存在中间的数等于第一个数，并且中间的数还属于后一个子数组，因为这样第一个数和最后一个数必然相同，矛盾

代码

这样一来，代码如下：

#include <cstdio>
#include <exception>

int MinInOrder(int* numbers, int index1, int index2);

int Min(int* numbers, int length)
{
	if (numbers == nullptr || 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;
		if (numbers[index1] == numbers[index2])
		{
			return MinInOrder(numbers, index1, index2);
		}

		if (numbers[index1] >= numbers[indexMid])
		{
			index2 = indexMid;
		}
		else if (numbers[index1] < numbers[indexMid])
		{
			index1 = indexMid;
		}
	}
	// 循环结束，指针的位置被保留了下来
	return numbers[indexMid];
}

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

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);

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

	return 0;
	
}

结果

总结

新的概念：旋转的数组。
二分查找法的使用非常重要，但是二分查找法在特定条件下的局限性也要清楚。
考虑问题要全面，能不用遍历这种原始的方法就尽量不要使用。