LeetCode Find Minimum In Rotated Sorted Array

#include <iostream>
#include <cstdlib>
#include <vector>

using namespace std;
// 4 5 1 2
// 1 2
class Solution {
public:
    int findMin(vector<int> &num) {
        int len = num.size();
        if (len < 1) {
            // should not happened;
            return 0;
        }
        if (len == 1) {
            return num[0];
        } 
        int p = 0; 
        int q = len - 1;
        
        // array with no rotation
        if (num[p] < num[q]) {
            return num[p];
        }
        
        // array been rotated
        while (p + 1 < q) {
            int m = (p + q) / 2;
            if (num[m] > num[q]) {
                p = m;
            } else if (num[m] < num[q]){
                q = m;
            }
        }
        return num[q];
    }
};

int main() {

    //int arr[] = {4, 5, 6, 7, 0, 1, 2};
    //int arr[] = {1, 2, 3};
    int arr[] = {1, 2};
    //int arr[] = {2, 1};
    vector<int> array(arr, arr + sizeof(arr) / sizeof(int));
    
    Solution s;
    
    cout<<s.findMin(array)<<endl;    
    
    return 0;
}

 

第二轮：

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

Find the minimum element.

You may assume no duplicate exists in the array.

class Solution {
public:
    int findMin(vector<int> &num) {
        int n = num.size();
        if (n < 1) {
            return INT_MIN;
        }
        if (n == 1) {
            return num[0];
        }
        int m = min(num[0], num.back());
        
        if (m == num[0]) {
            return m;
        }
        
        int p = -1;
        int q = n;
        while (p + 1 < q) {
            int mid = (p + q) / 2;
            if (num[mid] > m) {
                p = mid;
            }  else {
                q = mid;
            }
        }
        return num[q];
    }
};

 上面写的太烦，二分搜索其实对于其实下标的选取还是很有讲究的，因为问题中的解的元素的索引空间就是在0...n-1之间，所以直接令p=0, q=n-1即可。如果是纯粹的二分搜索的话一般是初始为p=0, q=n（其实是用lower_bound的初始），因为元素可能不在0...n-1之间。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int len = nums.size();
        int p = 0, q = len - 1;
        while (p < q) {
            int mid = (p + q) / 2;
            if (nums[mid] > nums[q]) {
                p = mid + 1;
            } else {
                q = mid;
            }
        }
        return nums[p];
    }
};