Find Minimum in Rotated Sorted Array II - Practice Coding Problems

Find Minimum in Rotated Sorted Array II - Problem

Imagine you have a sorted array that has been rotated at some pivot point, and it may contain duplicate elements. Your task is to find the minimum element in this rotated array as efficiently as possible.

What is array rotation? Rotating an array means moving elements from the end to the beginning. For example:

Original: [0,1,4,4,5,6,7]
Rotated 4 times: [4,5,6,7,0,1,4]
Rotated 7 times: [0,1,4,4,5,6,7] (back to original)

The Challenge: Unlike the version without duplicates, the presence of duplicate elements makes it impossible to always determine which half of the array to search in O(log n) time. Sometimes we need to handle the worst-case scenario where duplicates appear at critical positions.

Goal: Return the minimum element while minimizing the number of operations.

Input & Output

example_1.py — Basic Rotation

$ Input: [2,2,2,0,1]

› Output: 0

💡 Note: The array was originally [0,1,2,2,2] and rotated. The minimum element is 0.

example_2.py — Heavy Duplicates

$ Input: [1,3,3]

› Output: 1

💡 Note: The array has duplicates but no rotation. The minimum element is 1.

example_3.py — All Same Elements

$ Input: [3,3,3,3,3]

› Output: 3

💡 Note: All elements are the same, so the minimum is 3. This is the worst case for binary search.

Constraints

n == nums.length
1 ≤ n ≤ 5000
-5000 ≤ nums[i] ≤ 5000
nums is sorted and rotated between 1 and n times
Follow up: This problem is similar to Find Minimum in Rotated Sorted Array, but nums may contain duplicates. Would this affect the runtime complexity? How and why?

Visualization

Tap to expand

Understanding the Visualization

Set Boundaries

Place markers at the leftmost and rightmost books you need to consider

Check Middle

Look at the book in the middle of your current range

Make Decision

Compare middle book with rightmost book to determine which half likely contains the minimum

Handle Ties

When middle and right books have same page count, remove the rightmost duplicate to make progress

Key Takeaway

🎯 Key Insight: Binary search with duplicate handling - when we can't decide which half to search due to equal elements, we sacrifice one element from the boundary to make progress, maintaining logarithmic performance in most cases.

Asked in

a Amazon 42 ⊞ Microsoft 35 G Google 28 f Meta 22 Apple 18

The optimal solution uses modified binary search that handles duplicates intelligently. When duplicates prevent us from determining which half to search, we incrementally remove duplicates from boundaries. This maintains O(log n) average case while gracefully degrading to O(n) only when necessary.

Common Approaches

Approach	Time	Space	Notes
✓ Modified Binary Search (Optimal)	O(log n) average, O(n) worst case	O(1)	Use binary search with special handling for duplicates
Linear Scan	O(n)	O(1)	Scan through entire array to find minimum element

Modified Binary Search (Optimal) — Algorithm Steps

Initialize left and right pointers
While left < right, calculate mid point
If nums[mid] < nums[right], minimum is in left half
If nums[mid] > nums[right], minimum is in right half
If nums[mid] == nums[right], can't decide - remove duplicate from right
Return nums[left] when pointers meet

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left=0, right=n-1

Calculate Mid

Find middle point between left and right

Compare & Decide

Compare nums[mid] with nums[right] to choose direction

Handle Duplicates

When equal, shrink right boundary to eliminate duplicates

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int findMin(int* nums, int numsSize) {
    // Find minimum in rotated sorted array with duplicates - Modified Binary Search
    int left = 0, right = numsSize - 1;
    
    while (left < right) {
        int mid = (left + right) / 2;
        
        if (nums[mid] < nums[right]) {
            // Minimum is in left half (including mid)
            right = mid;
        } else if (nums[mid] > nums[right]) {
            // Minimum is in right half (excluding mid)
            left = mid + 1;
        } else {
            // nums[mid] == nums[right], can't determine which half
            // Remove duplicate from right to make progress
            right--;
        }
    }
    
    return nums[left];
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for array format [1,2,3]
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],\n ");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", findMin(nums, count));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n) average, O(n) worst case

Binary search gives O(log n) in most cases, but when array is full of duplicates we might need to check all elements

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for pointers

✓ Linear Space

73.9K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Modified Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler