Merge Intervals - Practice Coding Problems

Merge Intervals - Problem

Array Sorting Medium

Imagine you're a calendar app developer who needs to simplify a user's busy schedule. Given an array of time intervals where each interval is represented as [start, end], your task is to merge all overlapping intervals and return a clean, non-overlapping schedule.

For example, if someone has meetings from [1,3] and [2,6], these overlap and should be merged into a single interval [1,6]. Your goal is to take a messy schedule with potentially overlapping time slots and return the minimum number of intervals that cover the same time periods.

Key Points:

Two intervals [a,b] and [c,d] overlap if b ≥ c (they share at least one point)
The result should contain no overlapping intervals
The order of intervals in the result doesn't matter

Input & Output

example_1.py — Basic Overlapping Intervals

$ Input: intervals = [[1,3],[2,6],[8,10],[15,18]]

› Output: [[1,6],[8,10],[15,18]]

💡 Note: Intervals [1,3] and [2,6] overlap (since 2 ≤ 3), so they merge into [1,6]. The other intervals [8,10] and [15,18] don't overlap with any others, so they remain unchanged.

example_2.py — Adjacent Intervals

$ Input: intervals = [[1,4],[4,5]]

› Output: [[1,5]]

💡 Note: Intervals [1,4] and [4,5] are adjacent (they meet at point 4), which counts as overlapping. They merge into [1,5].

example_3.py — Single Interval

$ Input: intervals = [[1,4]]

› Output: [[1,4]]

💡 Note: With only one interval, there's nothing to merge. The result is the same as the input.

Visualization

Tap to expand

Understanding the Visualization

Messy Schedule

Executive has overlapping meetings: [1,3], [2,6], [8,10], [15,18]

Sort Chronologically

Organize meetings by start time - already sorted in this case

Smart Merging

Walk through meetings: [1,3] and [2,6] overlap (2 ≤ 3), merge to [1,6]

Continue Process

[8,10] doesn't overlap with [1,6] (8 > 6), keep separate

Clean Schedule

Final schedule: [1,6], [8,10], [15,18] - minimum time blocks!

Key Takeaway

🎯 Key Insight: By sorting intervals by start time first, we can make merging decisions locally - we only need to compare each interval with the last one in our result, not all previous intervals. This transforms an O(n²) problem into an O(n log n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

In worst case, we need O(n) iterations, each checking O(n) pairs, with O(n) time to merge

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for temporary variables

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁴
All intervals are valid (start ≤ end)

Asked in

G Google 127 a Amazon 98 f Meta 84 ⊞ Microsoft 73 Apple 56

The optimal solution uses a sorting + linear merge approach. First, sort intervals by start time in O(n log n). Then, iterate through sorted intervals once, merging overlapping intervals by checking if the current interval's start is ≤ the last merged interval's end. This achieves O(n log n) time complexity with O(n) space, making it the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Compare every interval with every other interval to find overlaps
Sorting + Linear Merge (Optimal)	O(n log n)	O(n)	Sort intervals by start time, then merge overlapping intervals in one pass

Brute Force (Nested Loops) — Algorithm Steps

Start with the original list of intervals
For each interval, check it against all other intervals
If two intervals overlap, merge them and remove the original two
Repeat until no more overlaps are found
Return the final list

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with all intervals: [1,3], [2,6], [8,10], [15,18]

First Pass

Compare [1,3] with [2,6] - they overlap! Merge to [1,6]

Continue Checking

Check [1,6] with [8,10] - no overlap. Check [8,10] with [15,18] - no overlap

Final Result

Result: [1,6], [8,10], [15,18]

Code -

solution.c — C

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

int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) {
    if (intervalsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int** result = (int**)malloc(intervalsSize * sizeof(int*));
    for (int i = 0; i < intervalsSize; i++) {
        result[i] = (int*)malloc(2 * sizeof(int));
        result[i][0] = intervals[i][0];
        result[i][1] = intervals[i][1];
    }
    int resultSize = intervalsSize;
    
    int merged = 1;
    while (merged) {
        merged = 0;
        for (int i = 0; i < resultSize && !merged; i++) {
            for (int j = i + 1; j < resultSize; j++) {
                // Check if intervals overlap
                if (result[i][1] >= result[j][0] && result[j][1] >= result[i][0]) {
                    // Merge intervals
                    int newStart = result[i][0] < result[j][0] ? result[i][0] : result[j][0];
                    int newEnd = result[i][1] > result[j][1] ? result[i][1] : result[j][1];
                    
                    // Remove both intervals and add merged one
                    free(result[i]);
                    free(result[j]);
                    
                    int maxIdx = i > j ? i : j;
                    int minIdx = i < j ? i : j;
                    
                    // Shift elements
                    for (int k = maxIdx; k < resultSize - 1; k++) {
                        result[k] = result[k + 1];
                    }
                    resultSize--;
                    for (int k = minIdx; k < resultSize - 1; k++) {
                        result[k] = result[k + 1];
                    }
                    resultSize--;
                    
                    result[resultSize] = (int*)malloc(2 * sizeof(int));
                    result[resultSize][0] = newStart;
                    result[resultSize][1] = newEnd;
                    resultSize++;
                    merged = 1;
                    break;
                }
            }
        }
    }
    
    *returnSize = resultSize;
    *returnColumnSizes = (int*)malloc(resultSize * sizeof(int));
    for (int i = 0; i < resultSize; i++) {
        (*returnColumnSizes)[i] = 2;
    }
    
    return result;
}

int main() {
    // Simple test case parsing
    int intervals[][2] = {{1,3},{2,6},{8,10},{15,18}};
    int* intervalsPtr[4];
    for (int i = 0; i < 4; i++) {
        intervalsPtr[i] = intervals[i];
    }
    int intervalsColSize[] = {2,2,2,2};
    int returnSize;
    int* returnColumnSizes;
    
    int** result = merge(intervalsPtr, 4, intervalsColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

In worst case, we need O(n) iterations, each checking O(n) pairs, with O(n) time to merge

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for temporary variables

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁴
All intervals are valid (start ≤ end)

128.5K Views

Very High Frequency

~18 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler