寫在前面，

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