Insert Interval - Practice Coding Problems

Insert Interval - Problem

Array Medium

You are given an array of non-overlapping intervals where each interval is represented as [start, end]. The intervals are already sorted by their start times in ascending order.

Your task is to insert a new interval into this array while maintaining the sorted order and ensuring no intervals overlap. If the new interval overlaps with existing intervals, you must merge them into a single interval.

Goal: Return the updated array of intervals after inserting the new interval.

Example: If you have intervals [[1,3],[6,9]] and want to insert [2,5], the result should be [[1,5],[6,9]] because [1,3] and [2,5] overlap and merge into [1,5].

Input & Output

example_1.py — Basic Insertion

$ Input: intervals = [[1,3],[6,9]], newInterval = [2,5]

› Output: [[1,5],[6,9]]

💡 Note: The new interval [2,5] overlaps with [1,3], so they merge into [1,5]. The interval [6,9] doesn't overlap, so it remains unchanged.

example_2.py — Multiple Merges

$ Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]

› Output: [[1,2],[3,10],[12,16]]

💡 Note: The new interval [4,8] overlaps with [3,5], [6,7], and [8,10]. All these intervals merge into [3,10].

example_3.py — Insert at Beginning

$ Input: intervals = [[3,5],[6,9]], newInterval = [1,2]

› Output: [[1,2],[3,5],[6,9]]

💡 Note: The new interval [1,2] doesn't overlap with any existing intervals and comes before all of them, so it's inserted at the beginning.

Visualization

Tap to expand

Understanding the Visualization

Scan Early Meetings

Copy all meetings that end before your new meeting starts

Handle Conflicts

Merge your new meeting with all overlapping existing meetings

Copy Remaining

Add all later meetings that don't conflict with the merged meeting

Key Takeaway

🎯 Key Insight: Process intervals in three distinct phases to achieve optimal O(n) time complexity while maintaining the sorted order property.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all intervals, each interval processed once

✓ Linear Growth

Space Complexity

O(n)

O(n) space for the result array, no additional data structures needed

⚡ Linearithmic Space

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁵
intervals is sorted by start_i in ascending order
newInterval.length == 2
0 ≤ start ≤ end ≤ 10⁵

Asked in

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

The optimal solution uses a three-phase linear scan approach: first copy all intervals that end before the new interval starts, then merge all overlapping intervals with the new one, and finally copy all remaining non-overlapping intervals. This achieves O(n) time complexity by utilizing the pre-sorted property of the input intervals.

Common Approaches

Approach	Time	Space	Notes
✓ One Pass Linear Scan (Optimal)	O(n)	O(n)	Process intervals in three phases: before, overlapping, and after the new interval
Brute Force (Check All Intervals)	O(n log n)	O(n)	Insert new interval and rebuild entire array by checking all overlaps

One Pass Linear Scan (Optimal) — Algorithm Steps

Add all intervals that end before newInterval starts
Merge newInterval with all overlapping intervals
Add all remaining intervals that start after merged interval
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Phase 1: Before

Copy intervals that end before new interval starts

Phase 2: Merge

Merge all overlapping intervals with new interval

Phase 3: After

Copy remaining intervals that don't overlap

Code -

solution.c — C

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

#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MAX(a,b) ((a) > (b) ? (a) : (b))

int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* newInterval, int newIntervalSize, int* returnSize, int** returnColumnSizes) {
    int** result = malloc((intervalsSize + 1) * sizeof(int*));
    *returnColumnSizes = malloc((intervalsSize + 1) * sizeof(int));
    int resultSize = 0;
    int i = 0;
    
    // Add all intervals that end before newInterval starts
    while (i < intervalsSize && intervals[i][1] < newInterval[0]) {
        result[resultSize] = malloc(2 * sizeof(int));
        result[resultSize][0] = intervals[i][0];
        result[resultSize][1] = intervals[i][1];
        (*returnColumnSizes)[resultSize] = 2;
        resultSize++;
        i++;
    }
    
    // Merge all overlapping intervals with newInterval
    while (i < intervalsSize && intervals[i][0] <= newInterval[1]) {
        newInterval[0] = MIN(newInterval[0], intervals[i][0]);
        newInterval[1] = MAX(newInterval[1], intervals[i][1]);
        i++;
    }
    
    result[resultSize] = malloc(2 * sizeof(int));
    result[resultSize][0] = newInterval[0];
    result[resultSize][1] = newInterval[1];
    (*returnColumnSizes)[resultSize] = 2;
    resultSize++;
    
    // Add all remaining intervals
    while (i < intervalsSize) {
        result[resultSize] = malloc(2 * sizeof(int));
        result[resultSize][0] = intervals[i][0];
        result[resultSize][1] = intervals[i][1];
        (*returnColumnSizes)[resultSize] = 2;
        resultSize++;
        i++;
    }
    
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all intervals, each interval processed once

✓ Linear Growth

Space Complexity

O(n)

O(n) space for the result array, no additional data structures needed

⚡ Linearithmic Space

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁵
intervals is sorted by start_i in ascending order
newInterval.length == 2
0 ≤ start ≤ end ≤ 10⁵

39.2K Views

High Frequency

~15 min Avg. Time

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

One Pass Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler