Find First and Last Position of Element in Sorted Array

Find First and Last Position of Element in Sorted Array - Problem

Search Range in Sorted Array

You are given a sorted array of integers and need to find the starting and ending positions of a specific target value. This is a classic problem that tests your understanding of binary search optimization.

The Challenge: Given an array nums sorted in non-decreasing order, find the first and last occurrence of a target value. If the target doesn't exist, return [-1, -1].

The Twist: You must solve this in O(log n) time complexity, which means a simple linear scan won't cut it!

Example:
Input: nums = [5,7,7,8,8,8,10], target = 8
Output: [3,5] (target 8 appears from index 3 to 5)

This problem is fundamental for understanding binary search variations and is frequently asked in technical interviews at major tech companies.

Input & Output

example_1.py — Basic Range Search

$ Input: nums = [5,7,7,8,8,8,10], target = 8

› Output: [3,5]

💡 Note: Target 8 appears at indices 3, 4, and 5. The first occurrence is at index 3 and the last occurrence is at index 5, so we return [3,5].

example_2.py — Target Not Found

$ Input: nums = [5,7,7,8,8,8,10], target = 6

› Output: [-1,-1]

💡 Note: Target 6 does not exist in the array, so we return [-1,-1] as specified in the problem statement.

example_3.py — Empty Array

$ Input: nums = [], target = 0

› Output: [-1,-1]

💡 Note: The array is empty, so the target cannot be found. We return [-1,-1].

Constraints

0 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
nums is a non-decreasing array
-10⁹ ≤ target ≤ 10⁹
Follow up: Could you write an algorithm with O(log n) runtime complexity?

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Set up two binary searches with left and right pointers

Find First Occurrence

When target found, continue searching left to find the earliest occurrence

Find Last Occurrence

When target found, continue searching right to find the latest occurrence

Return Range

Combine results to return [first, last] positions

Key Takeaway

🎯 Key Insight: Use two modified binary searches - one biased towards finding the leftmost occurrence, another biased towards finding the rightmost occurrence. This achieves O(log n) complexity by leveraging the sorted array property.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 24 Apple 19

The optimal solution uses two binary searches to achieve O(log n) time complexity. First binary search finds the leftmost occurrence by continuing to search left even when target is found. Second binary search finds the rightmost occurrence by continuing to search right when target is found. This approach efficiently utilizes the sorted property of the array.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use two binary searches to find leftmost and rightmost positions
Linear Search (Brute Force)	O(n)	O(1)	Scan the entire array once to find first and last positions

Binary Search (Optimal) — Algorithm Steps

Implement a helper function to find the leftmost occurrence using binary search
Implement a helper function to find the rightmost occurrence using binary search
In leftmost search: when target is found, continue searching left to find the first occurrence
In rightmost search: when target is found, continue searching right to find the last occurrence
Return [leftmost, rightmost] positions, or [-1, -1] if target not found

Visualization

Tap to expand

Step-by-Step Walkthrough

First Binary Search

Search for leftmost occurrence, continue left when target found

Found leftmost at index 3

Target 8 first appears at position 3

Second Binary Search

Search for rightmost occurrence, continue right when target found

Found rightmost at index 5

Target 8 last appears at position 5

Code -

solution.c — C

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

int findFirst(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int first = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            first = mid;
            right = mid - 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return first;
}

int findLast(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int last = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            last = mid;
            left = mid + 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return last;
}

int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (numsSize == 0) {
        result[0] = -1;
        result[1] = -1;
        return result;
    }
    
    result[0] = findFirst(nums, numsSize, target);
    result[1] = findLast(nums, numsSize, target);
    
    return result;
}

int main() {
    int nums[] = {5,7,7,8,8,8,10};
    int returnSize;
    int* result = searchRange(nums, 7, 8, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We perform two binary searches, each taking O(log n) time, so total is O(log n) + O(log n) = O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space for variables, no additional data structures

✓ Linear Space

73.9K 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

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler