[leetcode]Find Minimum in Rotated Sorted Array II

Find Minimum in Rotated Sorted Array II

 

Follow up for "Find Minimum in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

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.

The array may contain duplicates.

class Solution {
public:
    int findMin(vector<int>& nums, int b, int e){
        int minVal = nums[b];
        for(int i = b + 1; i <= e; i++){
            minVal = min(minVal, nums[i]);
        }
        return minVal;
    }
    int findMin(vector<int>& nums) {
        int mid;  
        int left = 0;  
        int right = nums.size() - 1;  
        
        while(left < right){  
            mid = left + (right - left) / 2;
            if(nums[mid] == nums[right] && nums[mid] == nums[left]){
                 return findMin(nums, left, right);
            }
            if(nums[mid] == nums[left]){
                if(nums[mid] < nums[right]){ // --/-
                    return findMin(nums, mid, right);
                }  
                if(nums[mid] > nums[right]){ //--\ -
                    left = mid + 1;
                    continue;
                }
            }
            if(nums[mid] == nums[right]){
                if(nums[mid] < nums[left]){// \--  
                    return findMin(nums, left, mid);
                }
                if(nums[mid] > nums[left]){//  /--   -
                    right = mid - 1;
                    continue;
                }
            }
            
            if(nums[mid] > nums[right]){ //  1、/\  2、/  
                left = mid + 1;  
            }else{  
                //正好位于拐点 3、\/ 4、\  -  
                if(nums[mid] < nums[mid - 1]){  
                    return nums[mid];  
                }  
                right = mid - 1;  
            }  
        }  
          
        return nums[left];         
    }
};