LeetCode – Find Minimum in Rotated Sorted Array II (Java)

Category: Algorithms >> Interview March 6, 2014

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

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

Java Solution 1 - Recursion

This is a follow-up problem of finding minimum element in rotated sorted array without duplicate elements. We only need to add one more condition, which checks if the left-most element and the right-most element are equal. If they are we can simply drop one of them. In my solution below, I drop the left element whenever the left-most equals to the right-most.

public int findMin(int[] num) {
    return findMin(num, 0, num.length-1);
}
 
public int findMin(int[] num, int left, int right){
    if(right==left){
        return num[left];
    }
    if(right == left +1){
        return Math.min(num[left], num[right]);
    }
    // 3 3 1 3 3 3
 
    int middle = (right-left)/2 + left;
    // already sorted
    if(num[right] > num[left]){
        return num[left];
    //right shift one
    }else if(num[right] == num[left]){
        return findMin(num, left+1, right);
    //go right    
    }else if(num[middle] >= num[left]){
        return findMin(num, middle, right);
    //go left    
    }else{
        return findMin(num, left, middle);
    }
}

Java Solution 2 - Iteration

public int findMin(int[] nums) {
    int i=0;
    int j=nums.length-1;
 
    while(i<=j){
 
        //handle cases like [3, 1, 3]
        while(nums[i]==nums[j] && i!=j){
            i++;
        }
 
        if(nums[i]<=nums[j]){
            return nums[i];
        }
 
        int m=(i+j)/2;
        if(nums[m]>=nums[i]){
            i=m+1;
        }else{
            j=m;
        }
    }
 
    return -1;
}

If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:

<pre><code> 
String foo = "bar";
</code></pre>

Larry Okeke

If the worst case is an array of one number duplicated many times… I agree with you
Larry Okeke

public static void solution(){ arr = new int[] {6, 7, 8, 9, 1, 1, 2, 2, 3, 4, 5}; int solut = recurse(0, 5, 9); log(solut+" "); } public static int recurse(int l, int middle, int r){ if(r - l <= 2) return (arr[l] < arr[r]) ? arr[l] : arr[r]; if(arr[l] arr[l]) return recurse(l, (middle/2)+1, middle); return recurse(middle, middle + middle/2, r) ;
}
Khatri

okay! got it. It is still O(log(n)).Right?
Khatri

What is the time complexity for this method? I think in worst case it will O(n), Please correct me if I am wrong! Thank you.

LeetCode – Find Minimum in Rotated Sorted Array II (Java)

Related posts: