Search in Rotated Sorted Array - Practice Coding Problems

Search in Rotated Sorted Array - Problem

Imagine you have a sorted library bookshelf that someone accidentally rotated! 📚

You're given an integer array nums that was originally sorted in ascending order with distinct values. However, before reaching you, this array was left rotated at some unknown pivot point k, where 1 ≤ k < nums.length.

What does rotation mean?
If we rotate [0,1,2,4,5,6,7] left by 3 positions, we get [4,5,6,7,0,1,2]. The elements [4,5,6,7] moved to the front, and [0,1,2] wrapped around to the back.

Your mission: Find the index of a target value in this rotated array, or return -1 if it doesn't exist.

The catch: You must solve this in O(log n) time complexity - no linear scanning allowed!

Examples:
• nums = [4,5,6,7,0,1,2], target = 0 → return 4
• nums = [4,5,6,7,0,1,2], target = 3 → return -1

Input & Output

example_1.py — Basic rotation with target found

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

› Output: 4

💡 Note: The target 0 is found at index 4. The array was rotated 4 positions to the left from [0,1,2,4,5,6,7].

example_2.py — Target not in array

$ Input: nums = [4,5,6,7,0,1,2], target = 3

› Output: -1

💡 Note: The target 3 is not present in the array, so we return -1.

example_3.py — Single element array

$ Input: nums = [1], target = 0

› Output: -1

💡 Note: Edge case: single element array where target is not found.

Constraints

1 ≤ nums.length ≤ 5000
-10⁴ ≤ nums[i] ≤ 10⁴
All values of nums are unique
nums is an ascending array that is possibly rotated
-10⁴ ≤ target ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Look at the middle book

Find the middle position and examine that book's number

Identify the sorted section

Determine whether the left or right section is properly ordered

Check if target is in sorted section

See if your target book number falls within the ordered section's range

Eliminate half the shelf

Focus on the half that could contain your book and repeat

Key Takeaway

🎯 Key Insight: In a rotated sorted array, one half is always perfectly sorted - use this to eliminate half the search space each time, achieving O(log n) efficiency!

Asked in

G Google 85 a Amazon 72 f Meta 65 ⊞ Microsoft 58 Apple 45

The optimal solution uses modified binary search to achieve O(log n) time complexity. The key insight is that in any rotated sorted array, at least one half is always properly sorted. By identifying the sorted half and checking if our target lies within its range, we can eliminate half the search space in each iteration, just like traditional binary search.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search	O(n)	O(1)	Check every element one by one until target is found
Modified Binary Search (Optimal)	O(log n)	O(1)	Use binary search by determining which half is sorted and contains the target

Linear Search — Algorithm Steps

Start from the first element
Compare each element with the target
Return index if found, -1 if we reach the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin checking from the first element

Compare each element

Check if current element matches target

Continue or return

Return index if found, otherwise continue to next element

Code -

solution.c — C

#include <stdio.h>

int search(int* nums, int numsSize, int target) {
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == target) {
            return i;
        }
    }
    return -1;
}

int main() {
    int nums[] = {4, 5, 6, 7, 0, 1, 2};
    int target = 0;
    printf("%d\n", search(nums, 7, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We potentially need to check every element in the worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the loop variable

✓ Linear Space

71.2K Views

Very 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