Search in Rotated Sorted Array

Search in Rotated Sorted Array - Problem

There is an integer array nums sorted in ascending order (with distinct values). Prior to being passed to your function, nums is possibly left rotated at an unknown index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed).

For example, [0,1,2,4,5,6,7] might be left rotated by 3 indices and become [4,5,6,7,0,1,2].

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

You must write an algorithm with O(log n) runtime complexity.

Input & Output

Example 1 — Target Found

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

› Output: 4

💡 Note: The array was rotated at index 4. Target 0 is found at index 4.

Example 2 — Target Not Found

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

› Output: -1

💡 Note: Target 3 does not exist in the array, so return -1.

Example 3 — Single Element

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

› Output: -1

💡 Note: 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

Asked in

A Amazon 45 G Google 38 M Microsoft 32 F Facebook 28

The key insight is that in any rotated sorted array, at least one half is always properly sorted. We can use modified binary search to determine which half is sorted and whether our target lies within that sorted range. Best approach uses binary search: Time: O(log n), Space: O(1)

Common Approaches

✓ Linear Search

⏱️ Time: O(n) Space: O(1)

The simplest approach is to ignore the rotation property and just iterate through each element until we find the target or reach the end.

Modified Binary Search

⏱️ Time: O(log n) Space: O(1)

Since at least one half of a rotated sorted array is always properly sorted, we can use binary search by checking which half is sorted and whether our target lies in that range.

Linear Search — Algorithm Steps

Iterate through each element in the array
Compare each element with target
Return index if found, -1 if not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at index 0

Compare

Check if current element equals target

Move

Move to next index if not found

Code -

solution.c — C

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

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers until ']'
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number using strtol
        char* endptr;
        long num = strtol(p, &endptr, 10);
        if (endptr != p) {
            arr[(*size)++] = (int)num;
            p = endptr;
        } else {
            p++;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    parseArray(line, nums, &numsSize);
    
    int target;
    scanf("%d", &target);
    
    int result = solution(nums, numsSize, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n elements in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for loop variable

✓ Linear Space

89.4K Views

High Frequency

~25 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