剑指offer11--旋转数组的最小数字——java/C++实现

题目描述

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

 

思路：

非减序列---递增序列+相邻可能相等的序列

 

既然旋转了，那么我们直接找到比前一个元素小（如果是递增序列，就是小于等于）的就对了，

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

这样时间复杂度实际上还是O（n）；

 

二分查找的思路：

class Solution {
public:
	int minNumberInRotateArray(vector<int> rotateArray) {
		if(rotateArray.size()==0) return 0;
		vector<int>::iterator itleft=rotateArray.begin();
		vector<int>::iterator itright=rotateArray.end()-1;
		while(itleft<itright-1){
			int left=itleft-rotateArray.begin();
			int right=itright-rotateArray.begin();
			vector<int>::iterator itmid=rotateArray.begin()+(left+right)/2;
			if(*itleft>*itmid)
				itright=itmid;
			else
				itleft=itmid;
		}
		return *itright;
	}
};

但是还是有问题：

11101 和10111解释不了。因为题目说是非减序列

所以如果判断出来相等，最好是直接采用第一种方法，循环找到小于前一个的数即可。

// vector::begin/end
#include <iostream>
#include <vector>

using namespace std;
int minNumberInRotateArray1(vector<int> rotateArray) {
	if(rotateArray.size()==0) return 0;
	int res=rotateArray[0];
	for(int i=1;i<rotateArray.size();i++){
		if(rotateArray[i]<rotateArray[i-1]){
			res=rotateArray[i];
			break;
		}
	}
	return res;
}
int minNumberInRotateArray(vector<int> rotateArray) {
		if(rotateArray.size()==0) return 0;
		vector<int>::iterator itleft=rotateArray.begin();
		vector<int>::iterator itright=rotateArray.end()-1;
		while(itleft<itright-1){
			int left=itleft-rotateArray.begin();
			int right=itright-rotateArray.begin();
			/*不能直接进行itmid=(itleft+itright)/2*/
			vector<int>::iterator itmid;
			itmid=rotateArray.begin()+(left+right)/2;
			//itmid=(itleft+itright)/2;
			if(*itleft>*itmid)
				itright=itmid;
			else if(*itleft<*itmid)
				itleft=itmid;
			else
				return minNumberInRotateArray1(rotateArray);
		}
		return *itright;
	}

int main ()
{
	/*int arr[]={6501,6828,6963,7036,7422,7674,8146,8468,8704,
8717,9170,9359,9719,9895,9896,9913,9962,
154,293,334,492,1323,1479,1539,1727,1870,1943,
2383,2392,2996,3282,3812,3903,4465,4605,4665,4772,
4828,5142,5437,5448,5668,5706,5725,6300,6335};*/
	int arr[]={1,0,1,1,1};
	int n=sizeof(arr)/sizeof(int);
	std::vector<int> myvector(arr,arr+n);
	int res=minNumberInRotateArray(myvector);
	cout<<res<<endl;
	return 0;

}

 

关键还是在于非递增，如何判断相等的情况

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int length = array.length;
        if(length==0){
            return 0;
        }
        int left = 0;
        int right = length-1;
        int middle = 0;
        while(array[left]>=array[right]){
            if(left == right - 1){
                middle = right;
                break;
            }
            
            middle = (left + right )/2;
            
            if(array[left]==array[right]
              &&array[left]==array[middle]){
                for(int i = left + 1; i< right ; i++){
                    if(array[left]>array[i]){
                        return array[i];
                    }
                    left++;
                }
            }
            
            if(array[left]<=array[middle]){
                left = middle;
            }else{
                right = middle;
            }
        }
        return array[middle];
    }
}