Search Insert Position - Practice Coding Problems

Search Insert Position - Problem

Given a sorted array of distinct integers and a target value, your task is to find the exact position where the target belongs in the array.

If the target is already present, return its index. If it's not found, return the index where it would need to be inserted to keep the array sorted in ascending order.

The challenge: You must solve this with O(log n) time complexity, making it perfect for practicing binary search techniques!

Example: In array [1, 3, 5, 6] with target 5, return index 2. With target 2, return index 1 (where 2 should be inserted).

Input & Output

example_1.py — Target Found

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

› Output: 2

💡 Note: Target 5 exists in the array at index 2, so we return 2.

example_2.py — Insert Position

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

› Output: 1

💡 Note: Target 2 doesn't exist, but should be inserted at index 1 to maintain sorted order: [1,2,3,5,6].

example_3.py — Insert at End

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

› Output: 4

💡 Note: Target 7 is larger than all elements, so it should be inserted at the end (index 4).

Visualization

Tap to expand

Understanding the Visualization

Start in the Middle

Like opening a phone book to the middle page, we check the middle element first

Compare and Eliminate

If the middle element is too small, we know our target must be in the right half

Repeat the Process

We continue halving the search space until we find our target or determine where it belongs

Find the Position

When pointers cross, the left pointer indicates exactly where the target should be inserted

Key Takeaway

🎯 Key Insight: Binary search eliminates half the possibilities with each comparison, making it exponentially faster than linear search for sorted data

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each comparison eliminates half of the remaining elements

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant number of variables for pointers

✓ Linear Space

Constraints

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

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses binary search to achieve O(log n) time complexity. By repeatedly dividing the search space in half, we can efficiently find the target or determine its insertion position in a sorted array.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Divide and conquer by repeatedly halving the search space
Linear Search	O(n)	O(1)	Check each element from left to right until finding the target or insertion point

Binary Search (Optimal) — Algorithm Steps

Initialize left pointer at 0, right pointer at array length - 1
While left <= right, calculate middle index
If middle element equals target, return middle index
If middle element < target, search right half (left = mid + 1)
If middle element > target, search left half (right = mid - 1)
If not found, left pointer gives insertion position

Visualization

Tap to expand

Step-by-Step Walkthrough

Set boundaries

Initialize left and right pointers

Find middle

Calculate middle index and compare with target

Eliminate half

Move left or right pointer based on comparison

Repeat until found

Continue until target found or pointers cross

Code -

solution.c — C

#include <stdio.h>

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

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each comparison eliminates half of the remaining elements

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant number of variables for pointers

✓ Linear Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler