面试题11：旋转数组的最小数字

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

 

1.一趟遍历寻找最小值-O(n)

class Solution
{
public:
	int minNumberInRotateArray(vector<int> rotateArray)
	{
		if(rotateArray.size() == 0)
		{
			return 0;
		}

		int min = INT_MAX;

		for (int i = 0; i < rotateArray.size(); i++)
		{
			if(rotateArray[i] < min)
			{
				min = rotateArray[i];
			}
		}

		return min;
	}
};

2.最大值后面的那个就是最小值

class Solution
{
public:
	int minNumberInRotateArray(vector<int> rotateArray)
	{
		for(int i = 0; i < rotateArray.size(); i++)
		{
			if(rotateArray[i] > rotateArray[i+1])
			{
				return rotateArray[i+1];
			}
		}
		return rotateArray[0];
	}
};

 

3.二分法（分治法）

 

首先我们用两个指针，分别指向数组的第一个元素和最后一个元素。按照题目旋转的规则，第一个元素应该是大于或者等于最后一个元素的（这其实不完全对，还有特例。后面再讨论特例）。

接着我们得到处在数组中间的元素

如果该中间元素位于前面的递增子数组，那么它应该大于或者等于第一个指针指向的元素。

此时数组中最小的元素应该位于该中间 元素的后面。我们可以把第一指针指向该中间元素，这样可以缩小寻找的范围。

同样，如果中间元素位于后面的递增子数组，那么它应该小于或者等于第二个指针指 向的元素。此时该数组中最小的元素应该位于该中间元素的前面。我们可以把第二个指针指向该中间元素，这样同样可以缩小寻找的范围。我们接着再用更新之后的 两个指针，去得到和比较新的中间元素，循环下去。

 

特殊情况及处理：

<1>如果数组旋转后仍然有序，即rotateArray[low] < rotateArray[high]

(如果把排序数组前面0个元素搬到后面，也就是说其实没有旋转)

那么第0个元素就是最小的元素

处理：mid = 0;

<2>如果rotateArray[low] == rotateArray[high]

 

测试用例: 

[1, 0, 1, 0, 1, 1]

对应输出应该为:

0

你的输出为:

1

 

此时rotateArray[low], rotateArray[mid], rotateArray[high]三者相等，无法确定中间元素属于前面还是后面的递增子数组，只能顺序查找

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
	int minNumberInRotateArray(vector<int> rotateArray) {
		int size = rotateArray.size();
		if(size==0)
		{
			return 0;
		}
		int left = 0, right = size - 1;
		int mid = 0;
		//rotateArray[left] >= rotateArray[right] 确保旋转
		while(rotateArray[left] >= rotateArray[right]) {
			if(right - left == 1)
			{
				mid = right;
				break;
			}
			mid = left + (right - left) / 2;
			//rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
			//无法确定中间元素是属于前面还是后面的递增子数组
			//只能顺序查找
			if(rotateArray[left] == rotateArray[right] && rotateAray[left] == rotateArray[right]){
				return MinOrder(rotateArray, left, right);
			}
			//中间元素位于前面的递增子数组
			//此时最小元素位于中间元素的后面
			if(rotateArray[mid] >= rotateArray[left]) {
				left = mid;
			} 
			//中间元素位于后面的递增子数组
			//此时最小元素位于中间元素的前面
			else {
				right = mid;
			}
		}
		return rotateArray[mid];
	}

private:
	int MinOrder(vector<int> &num, int left, int right)
	{
		int result = num[left];
		for (int i = left + 1; i < right; i++)
		{
			if(num[i] < result){
				result = num[i];
			}
		}
		return result;
	}
};

参考blog：https://blog.csdn.net/gatieme/article/details/51115386