旋轉數組的最小數字

旋轉數組的最小數字

題目描述

把一個數組最開始的若干個元素搬到數組的末尾，我們稱之為數組的旋轉。 輸入一個非減排序的數組的一個旋轉，輸出旋轉數組的最小元素。 例如數組{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉，該數組的最小值為1。 NOTE：給出的所有元素都大於0，若數組大小為0，請返回0。

特殊輸入{1, 2, 3, 4, 5}; {1, 1, 1, 0, 1}; {1, 0, 1, 1, 1}-->這時版本二, 三只能暴力查找了, 看看版本三med如何初始化

版本一: 從頭到尾遍歷數組找出最小值, 沒什么技術含量,

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

版本二: 遞歸版, vt[middle]和vt[start]之間用>還是>=是個疑問

class Solution {
public:
        int min(vector<int> vt) {
            int ret = 0;
            int len = vt.size();
            for (int i = 0; i < len; i++) {
                if (vt[i] > vt[i+1]) {
                    ret = vt[i+1];
                    break;
                }
            }
            
            return ret;
    }
    
    int find(vector<int> vt, int start, int end) {
        int ret;
        int middle = 0;
        
        middle = (start + end) / 2;
        
        if (start+1 == end) {
            
			//不需要這么判斷, start永遠指向最小值的前面元素
            //return vt[start] < vt[end] ? vt[start] : vt[end];	
			return vt[end];
        }
        
        
        if (vt[middle] == vt[start] == vt[middle] == vt[end]) {
            ret = min(vt);
        }
		// 這么判斷牛客上輸出結果在下圖
        //else if (vt[middle] > vt[start]) {		
        else if (vt[middle] >= vt[start]) {
            start = middle;
            ret = find(vt, start, end);
        }
        else if (vt[middle] <= vt[start]) {
            end = middle;
            ret = find(vt, start, end);
        }
        
        return ret;
    }
    
    int minNumberInRotateArray(vector<int> rotateArray) {
        int ret = 0;
        int len = rotateArray.size();
        
        if (0 == len) {
            ret = 0;
        }
        else if (1 == len) {
            ret = 1;
        }
        else {
            ret = find(rotateArray, 0, len - 1);
        }
        
        return ret;
    }
};

版本四: 非遞歸版二分法查找, ret初始化為數組第一個結點, 使用while(rotateArray[start] >= rotateArray[end])這么判斷, 當數組為有序時, 直接返回最小值

class Solution {
public:
        int min(vector<int> vt) {
            int ret = 0;
            int len = vt.size();
            for (int i = 0; i < len; i++) {
                if (vt[i] > vt[i+1]) {
                    ret = vt[i+1];
                    break;
                }
            }
            
            return ret;
    }
    
    int minNumberInRotateArray(vector<int> rotateArray) {
        int ret = 0;
        int start = 0;
        int end = 0;
        int med = start;
        
        if (0 == rotateArray.size()) {
            return ret;
        }
        
        end = rotateArray.size() - 1;
		ret = rotateArray[start];
        //while(1 != (end - start)) {
		while(rotateArray[start] >= rotateArray[end]) {

            if (rotateArray[start] == rotateArray[med] == rotateArray[end]) {
                ret = min(rotateArray);
                break;
            }
            
			med = (start + end) / 2;
            if (rotateArray[med] >= rotateArray[start]) {
                start = med;
            }
            else if ((rotateArray[med] <= rotateArray[end])) {
                end = med;
            }
			ret = rotateArray[end];        
		}
        
        return ret;
    }
};