Search Insert Position

Search Insert Position - Problem

Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

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

Input & Output

Example 1 — Target Found

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

› Output: 2

💡 Note: Target 5 exists at index 2, so return 2

Example 2 — Insert in Middle

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

› Output: 1

💡 Note: Target 2 should be inserted at index 1 to maintain sorted order: [1,2,3,5,6]

Example 3 — Insert at End

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

› Output: 4

💡 Note: Target 7 is larger than all elements, so insert at the end (index 4)

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
nums contains distinct values sorted in ascending order
-10⁴ ≤ target ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to leverage the sorted array property with binary search. Since the array is sorted, we can eliminate half the search space at each step by comparing the target with the middle element. Best approach is binary search with Time: O(log n), Space: O(1).

Common Approaches

✓ Binary Search

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

Since array is sorted, we can eliminate half the search space at each step. Compare target with middle element and narrow down to left or right half until we find the exact position.

Linear Search

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

Check each element one by one until we find the target or find the first element greater than target. If we reach the end without finding either, target goes at the end.

Binary Search — Algorithm Steps

Set left = 0, right = array length
While left < right, find mid = (left + right) / 2
If nums[mid] < target, search right half (left = mid + 1)
Else search left half (right = mid)
Return left as the insertion position

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Middle

Compare target with middle element

Narrow Range

Move left or right boundary based on comparison

Found Position

Converge to exact insertion point

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array more robustly
    int nums[10000];
    int numsSize = 0;
    
    // Find the opening bracket
    char* start = strchr(line, '[');
    if (start) {
        start++; // Move past '['
        char* end = strchr(start, ']');
        if (end) {
            *end = '\0'; // Null terminate before ']'
            
            char* token = strtok(start, ",");
            while (token != NULL) {
                // Skip whitespace
                while (isspace(*token)) token++;
                if (*token != '\0') {
                    nums[numsSize++] = atoi(token);
                }
                token = strtok(NULL, ",");
            }
        }
    }
    
    int target;
    scanf("%d", &target);
    
    int result = solution(nums, numsSize, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Search space halved at each step, maximum log n iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for left, right, mid pointers

✓ Linear Space

1.3M Views

High Frequency

~15 min Avg. Time

8.4K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler