Find Minimum in Rotated Sorted Array - Practice Coding Problems

Find Minimum in Rotated Sorted Array - Problem

Imagine you have a perfectly sorted array that someone has rotated - like taking a portion from the end and moving it to the beginning. Your mission is to find the minimum element in this rotated sorted array.

For example, the sorted array [0,1,2,4,5,6,7] might become:

[4,5,6,7,0,1,2] if rotated 4 times
[6,7,0,1,2,4,5] if rotated 2 times
[0,1,2,4,5,6,7] if rotated 7 times (full rotation)

The twist? You must solve this in O(log n) time - no linear scanning allowed! This means you need to be smarter than checking every element.

Goal: Return the minimum element from the rotated sorted array.

Input & Output

example_1.py — Basic rotation

$ Input: [3,4,5,1,2]

› Output: 1

💡 Note: The original sorted array [1,2,3,4,5] was rotated 3 times to become [3,4,5,1,2]. The minimum element is 1.

example_2.py — Heavy rotation

$ Input: [4,5,6,7,0,1,2]

› Output: 0

💡 Note: The original sorted array [0,1,2,4,5,6,7] was rotated 4 times. The minimum element 0 is now in the middle of the array.

example_3.py — No rotation

$ Input: [11,13,15,17]

› Output: 11

💡 Note: This array is not rotated (or rotated by the full length). The minimum element is at the beginning.

Constraints

n == nums.length
1 ≤ n ≤ 5000
-5000 ≤ nums[i] ≤ 5000
All elements in nums are unique
nums is sorted in ascending order and rotated between 1 and n times

Visualization

Tap to expand

Understanding the Visualization

Divide the array

Look at the middle element and compare with boundaries

Identify the sorted half

One half will be properly sorted, the other contains the rotation point

Choose the correct half

The minimum lies in the half containing the rotation point

Repeat until found

Continue halving until we pinpoint the minimum element

Key Takeaway

🎯 Key Insight: In a rotated sorted array, compare the middle with the rightmost element to determine which half contains the rotation point (and thus the minimum)

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28 Apple 22

The optimal solution uses binary search to achieve O(log n) time complexity. The key insight is that in a rotated sorted array, one half is always properly sorted. By comparing the middle element with the rightmost element, we can determine which half contains the minimum and eliminate the other half.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search	O(n)	O(1)	Check every element to find the minimum
Binary Search (Optimal)	O(log n)	O(1)	Use binary search to find the rotation point efficiently

Linear Search — Algorithm Steps

Initialize minimum as the first element
Iterate through each element in the array
Update minimum if current element is smaller
Return the minimum after checking all elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Initialize minimum as first element

Compare each element

Check if current element is smaller than current minimum

Update minimum

Replace minimum if smaller element found

Continue until end

Process all remaining elements

Code -

solution.c — C

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

int findMin(int* nums, int numsSize) {
    int minVal = nums[0];
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) {
            minVal = nums[i];
        }
    }
    return minVal;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    while ((c = getchar()) != '[');
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    printf("%d\n", findMin(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We need to check every element once in the worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a single variable to track the minimum

✓ Linear Space

89.5K Views

High Frequency

~15 min Avg. Time

2.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

Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler