Search in Rotated Sorted Array II - Practice Coding Problems

Search in Rotated Sorted Array II - Problem

Search in Rotated Sorted Array II

Imagine you have a sorted array that's been rotated at some unknown point. Think of it like a circular bookshelf that someone spun - the books are still in order, but the starting point has changed!

You're given an integer array nums that was originally sorted in non-decreasing order (with possible duplicates). Before reaching your function, this array was rotated at an unknown pivot index k, transforming [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]].

Example: The array [0,1,2,4,4,4,5,6,6,7] rotated at index 5 becomes [4,5,6,6,7,0,1,2,4,4].

Your Mission: Given this rotated array and a target value, return true if the target exists in the array, false otherwise. The challenge is to do this efficiently - can you beat the obvious linear search?

Input & Output

example_1.py — Basic rotation with target present

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

› Output: true

💡 Note: The array was originally [0,0,1,2,2,5,6] and rotated. The target 0 exists at indices 3 and 4, so we return true.

example_2.py — Target not present

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

› Output: false

💡 Note: The target 3 does not exist anywhere in the rotated array, so we return false.

example_3.py — All duplicates edge case

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

› Output: true

💡 Note: Even with many duplicates making it hard to determine rotation point, the target 0 exists at index 1.

Constraints

1 ≤ nums.length ≤ 5000
-10⁴ ≤ nums[i] ≤ 10⁴
-10⁴ ≤ target ≤ 10⁴
nums is guaranteed to be rotated at some pivot
Follow up: This problem is similar to Search 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

Find the Middle

Look at the middle element to divide the search space

Identify Sorted Half

Compare endpoints to determine which half maintains sorted order

Check Target Range

See if target could be in the sorted half

Eliminate & Repeat

Discard the half that can't contain target and repeat

Key Takeaway

🎯 Key Insight: In a rotated sorted array, we can always identify at least one sorted half and use that information to eliminate half the search space efficiently!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 22 Apple 18

The optimal approach uses a modified binary search that works with rotated sorted arrays. The key insight is that even after rotation, at least one half of the array remains sorted. We identify which half is sorted, check if our target lies within that range, and eliminate the other half. Due to duplicates, we may need to handle special cases where we can't determine which side is sorted, leading to O(log n) average case but O(n) worst case complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search	O(n)	O(1)	Check every element in the array one by one
Modified Binary Search	O(log n) average, O(n) worst case	O(1)	Use binary search with rotation awareness to efficiently locate the target

Linear Search — Algorithm Steps

Start from the first element
Compare each element with the target
Return true if target is found
Return false if we reach the end without finding the target

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Beginning

Begin checking from the first element

Sequential Check

Compare each element with target

Found or Complete

Return true if found, false if we reach the end

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool search(int* nums, int numsSize, int target) {
    // Linear search through rotated sorted array
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == target) {
            return true;
        }
    }
    return false;
}

int main() {
    int nums[] = {2,5,6,0,0,1,2};
    int target = 0;
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%s\n", search(nums, size, target) ? "true" : "false");
    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 iteration

✓ Linear Space

52.3K Views

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

Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler