Merge Intervals

Merge Intervals - Problem

Array Sorting Medium

Given an array of intervals where intervals[i] = [start_i, end_i], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.

Two intervals overlap if they share at least one common point. For example, [1,3] and [2,6] overlap because they share the range [2,3].

Example: If you have intervals [[1,3],[2,6],[8,10],[15,18]], the first two intervals overlap and should be merged into [1,6], resulting in [[1,6],[8,10],[15,18]].

Input & Output

Example 1 — 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 (share range [2,3]), so merge them into [1,6]. The other intervals [8,10] and [15,18] don't overlap with anything.

Example 2 — All Intervals Merge

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

› Output: [[1,5]]

💡 Note: Intervals [1,4] and [4,5] overlap at point 4, so they merge into [1,5].

Example 3 — No Overlaps

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

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

💡 Note: No intervals overlap, so the result is the same as input.

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁴

Visualization

Tap to expand

Asked in

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

The key insight is to sort intervals by start time first, which allows us to merge overlapping intervals in a single linear pass. The optimal approach has O(n log n) time complexity due to sorting, and O(n) space for the result array.

Common Approaches

✓ Brute Force - Check All Pairs

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

For each interval, check all other intervals to see if they overlap. Keep merging until no more overlaps exist. This requires multiple passes through the array.

Sort Then Merge

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

Sort all intervals by their start times first. Then iterate through the sorted intervals and merge any that overlap with the current merged interval. This is the optimal approach.

Brute Force - Check All Pairs — Algorithm Steps

Step 1: For each interval, find all overlapping intervals
Step 2: Merge overlapping intervals into one
Step 3: Repeat until no more merges possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare All Pairs

Check each interval against all others

Merge Overlaps

Combine overlapping intervals found

Repeat

Continue until no more merges possible

Code -

solution.c — C

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

int** solution(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) {
    if (intervalsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // Create a copy to work with
    int** result = (int**)malloc(intervalsSize * sizeof(int*));
    *returnColumnSizes = (int*)malloc(intervalsSize * sizeof(int));
    int currentSize = 0;
    
    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];
        (*returnColumnSizes)[i] = 2;
        currentSize++;
    }
    
    // Keep merging until no more overlaps
    int merged = 1;
    while (merged) {
        merged = 0;
        int i = 0;
        while (i < currentSize) {
            int j = i + 1;
            while (j < currentSize) {
                // Check if intervals[i] and intervals[j] overlap
                if (result[i][0] <= result[j][1] && result[j][0] <= result[i][1]) {
                    // Merge the intervals
                    result[i][0] = result[i][0] < result[j][0] ? result[i][0] : result[j][0];
                    result[i][1] = result[i][1] > result[j][1] ? result[i][1] : result[j][1];
                    
                    // Remove interval j
                    free(result[j]);
                    for (int k = j; k < currentSize - 1; k++) {
                        result[k] = result[k + 1];
                        (*returnColumnSizes)[k] = (*returnColumnSizes)[k + 1];
                    }
                    currentSize--;
                    merged = 1;
                } else {
                    j++;
                }
            }
            i++;
        }
    }
    
    *returnSize = currentSize;
    return result;
}

int parseNumber(char* str, int* pos) {
    int sign = 1;
    int num = 0;
    
    // Skip whitespace and non-digit characters except minus
    while (str[*pos] && !isdigit(str[*pos]) && str[*pos] != '-') (*pos)++;
    
    // Check for negative sign
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    // Parse digits
    while (str[*pos] && isdigit(str[*pos])) {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    
    return sign * num;
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    if (strlen(line) == 0 || strcmp(line, "[]") == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Parse 2D array
    int** intervals = (int**)malloc(1000 * sizeof(int*));
    int* intervalsColSize = (int*)malloc(1000 * sizeof(int));
    int intervalsSize = 0;
    
    int pos = 0;
    int len = strlen(line);
    
    while (pos < len) {
        // Find start of interval '['
        while (pos < len && line[pos] != '[') pos++;
        if (pos >= len) break;
        
        // Skip the opening bracket
        pos++;
        
        // Parse first number
        int first = parseNumber(line, &pos);
        
        // Skip comma and whitespace
        while (pos < len && (line[pos] == ',' || isspace(line[pos]))) pos++;
        
        // Parse second number
        int second = parseNumber(line, &pos);
        
        // Skip to closing bracket
        while (pos < len && line[pos] != ']') pos++;
        if (pos < len) pos++; // Skip the closing bracket
        
        // Create interval
        intervals[intervalsSize] = (int*)malloc(2 * sizeof(int));
        intervals[intervalsSize][0] = first;
        intervals[intervalsSize][1] = second;
        intervalsColSize[intervalsSize] = 2;
        intervalsSize++;
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(intervals, intervalsSize, intervalsColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < intervalsSize; i++) {
        free(intervals[i]);
    }
    free(intervals);
    free(intervalsColSize);
    
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops to find overlaps (O(n²)) and potentially n iterations to merge all

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for merging in place

✓ Linear Space

78.0K Views

High Frequency

~15 min Avg. Time

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

Visualization

Code -

Time & Space Complexity

Select Compiler