Codestin Search App

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.

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⁵

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.

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
✓ 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)	O(n)	O(n)	Process intervals in three phases: before, overlapping, and after the new interval

Brute Force (Check All Intervals) — Algorithm Steps

Add the new interval to the existing intervals array
Sort the entire array by start times
Iterate through sorted intervals and merge overlapping ones
Return the merged result

Visualization

Tap to expand

Step-by-Step Walkthrough

Add New Interval

Insert the new interval into the existing array

Sort All Intervals

Sort the entire array by start times

Merge Overlaps

Scan through and merge any overlapping intervals

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* ia = *(int**)a;
    int* ib = *(int**)b;
    return ia[0] - ib[0];
}

int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* newInterval, int newIntervalSize, int* returnSize, int** returnColumnSizes) {
    int** all = malloc((intervalsSize + 1) * sizeof(int*));
    for (int i = 0; i < intervalsSize; i++) {
        all[i] = intervals[i];
    }
    all[intervalsSize] = newInterval;
    
    qsort(all, intervalsSize + 1, sizeof(int*), compare);
    
    int** result = malloc((intervalsSize + 1) * sizeof(int*));
    *returnColumnSizes = malloc((intervalsSize + 1) * sizeof(int));
    int resultSize = 0;
    
    for (int i = 0; i < intervalsSize + 1; i++) {
        if (resultSize == 0 || result[resultSize - 1][1] < all[i][0]) {
            result[resultSize] = malloc(2 * sizeof(int));
            result[resultSize][0] = all[i][0];
            result[resultSize][1] = all[i][1];
            (*returnColumnSizes)[resultSize] = 2;
            resultSize++;
        } else {
            if (result[resultSize - 1][1] < all[i][1]) {
                result[resultSize - 1][1] = all[i][1];
            }
        }
    }
    
    *returnSize = resultSize;
    free(all);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting the array after insertion, plus O(n) for merging

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for storing the result array

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Intervals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler