写在前面,
1.这是我目前遇到最有趣的题目涵盖多种思路,多种解法,也是多种问题。故记录下来总结一下。半夜看到这道题,首先想到的是二分,后来一看最小,那不是直接遍历就行,但是T=O(n)。
2.左神的课程中提到过,对于二分搜索,一般大家都是mid=(left+right)/2,其实在数组特别大的时候会出现越界,故写成mid=left+(right-left)/2,这个是不一样的
【题目描述】:把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。 NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
【思路一】:不说了直接看代码。评论区:这种写法拿不到offer。很不推荐!
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
if(rotateArray.size()==0)
return 0;
sort(rotateArray.begin(),rotateArray.end());
return rotateArray[0];
}
};
class Solution:
def minNumberInRotateArray(self, rotateArray):
return min(rotateArray)
【思路二】就是遍历一遍数据,看看数据是否旋转,由于题目说明,数组时非递减的,如果后面的元素小于前面的元素,那一定就是这里发生了旋转,这个小的元素就是最小的啊,复杂度还是O(n);不是很优秀!
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
//数组为空时
if(rotateArray.size() == 0)
return 0;
//前部分数据旋转
for(int i = 0; i < rotateArray.size() - 1; i++){
if (rotateArray[i] > rotateArray[i + 1])
return rotateArray[i + 1];
}
//全部数据旋转,相当于没有旋转,最小数即为第一个数
return rotateArray[0];
}
};
【思路三】:二分查找。为什么想到了二分查找呢,就通过二分找到中间元素,比较中间元素与两端元素的大小,然后根据不同的比较结果,就可以得到小值在那里。大姐可以自己画一下,不是很复杂。但是需要注意每一种情况的边界条件和数列中的特殊情况。具体在代码中标注。复杂度为O(logn),并不用遍历数组。
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <algorithm>
using namespace std;
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
int size = rotateArray.size();
if(size == 0){
return 0;
}//if
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;
}//if
mid = left+(right-left)/2;
// rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
// 无法确定中间元素是属于前面还是后面的递增子数组
// 只能顺序查找
if(rotateArray[left] == rotateArray[right] && rotateArray[left] == rotateArray[mid]){
return MinOrder(rotateArray,left,right);
}//if
// 中间元素位于前面的递增子数组
// 此时最小元素位于中间元素的后面
if(rotateArray[mid] >= rotateArray[left]){
left = mid;
}//if
// 中间元素位于后面的递增子数组
// 此时最小元素位于中间元素的前面
else{
right = mid;
}//else
}//while
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];
}//if
}//for
return result;
}
};
int main(){
Solution s;
//vector<int> num = {0,1,2,3,4,5};
//vector<int> num = {4,5,6,7,1,2,3};
vector<int> num = {2,2,2,2,1,2};
int result = s.minNumberInRotateArray(num);
// 输出
cout<<result<<endl;
return 0;
}
//递归实现的二分代码
class Solution {
int findMin(vector<int> a, int first, int last) {
if (first >= last) return a[last];
int mid = first + (last-first) / 2;
if (a[first] == a[last] && a[mid] == a[first]) {
// linear search
int min = a[first];
for (int i = first + 1; i <= last; i++)
min = a[i]<min ? a[i] : min;
return min;
}
if (a[first] < a[last]) {
return a[first];
} else {
if (a[mid] >= a[first]) {
return findMin(a, mid + 1, last);
} else {
return findMin(a, first, mid);
}
}
}
public:
int minNumberInRotateArray(vector<int> rotateArray) {
int n = rotateArray.size();
if (n == 0) return 0;
return findMin(rotateArray, 0, n - 1);
}
};
//循环实现
class Solution {
public:
int minNumberInRotateArray(vector<int> array) {
if (array.size() == 0) return 0;
int first = 0, last = array.size() - 1;
int mid = first + (last-first) / 2;
while (array[first] >= array[last]) {
if (last - first == 1) return array[last];
if (array[first] == array[mid] && array[mid] == array[last]) {
// linear search
int min = array[first];
for (int i = first + 1; i <= last; i++)
min = array[i]<min ? array[i] : min;
return min;
}
if (array[first] <= array[mid]) first = mid;
else last = mid;
mid = (first + last) / 2;
}
return array[first];
}
};