剑指offer第六题数组旋转

写在前面，

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];
    }
};