Codestin Search App

Data Stream as Disjoint Intervals - Problem

Hash Table Binary Search Union Find Design Data Stream Ordered Set Hard

🌊 Data Stream as Disjoint Intervals

Imagine you're receiving a continuous stream of numbers and need to efficiently track which ranges of consecutive numbers you've seen. This is a classic data structure design problem that tests your ability to maintain sorted, disjoint intervals dynamically.

The Challenge: As numbers arrive one by one, you must:

Add each new number to your collection
Merge overlapping or adjacent intervals
Return all intervals sorted by their start points

Example: If you receive numbers [1, 3, 7, 2, 6], your intervals evolve like this:

After 1: [[1,1]]
After 3: [[1,1], [3,3]]
After 7: [[1,1], [3,3], [7,7]]
After 2: [[1,3], [7,7]] (merged!)
After 6: [[1,3], [6,7]]

You need to implement the SummaryRanges class with efficient addNum() and getIntervals() methods.

Input & Output

example_1.py — Basic Operations

$ Input: ["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"] [[], [1], [], [3], [], [2], []]

› Output: [null, null, [[1,1]], null, [[1,1],[3,3]], null, [[1,3]]]

💡 Note: Start empty, add 1 → [1,1], add 3 → [1,1],[3,3], add 2 → merges into [1,3] since 2 connects 1 and 3

example_2.py — Multiple Merges

$ Input: ["SummaryRanges", "addNum", "addNum", "addNum", "getIntervals", "addNum", "getIntervals"] [[], [1], [7], [3], [], [2], []]

› Output: [null, null, null, null, [[1,1],[3,3],[7,7]], null, [[1,3],[7,7]]]

💡 Note: Add 1,7,3 creates three separate intervals. Adding 2 merges [1,1] and [3,3] into [1,3]

example_3.py — Adjacent Intervals

$ Input: ["SummaryRanges", "addNum", "addNum", "addNum", "getIntervals"] [[], [1], [2], [4], []]

› Output: [null, null, null, null, [[1,2],[4,4]]]

💡 Note: 1 and 2 are consecutive so they merge into [1,2]. 4 is separate, creating [1,2],[4,4]

Constraints

0 ≤ value ≤ 10⁴
At most 3 × 10⁴ calls will be made to addNum and getIntervals
All values are non-negative integers
getIntervals should return intervals sorted by start position

Asked in

The optimal solution uses a TreeMap/balanced BST to maintain intervals sorted by start position. This enables O(log n) insertions by using floor/ceiling operations to efficiently find adjacent intervals for merging. The key insight is leveraging the tree's ordering properties to avoid linear scans.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search & Merge)	O(n) per addNum, O(n log n) per getIntervals	O(n)	Store intervals in a list and linear search for merge positions on each addition
Binary Search Insertion	O(log n) search + O(n) merge/shift = O(n)	O(n)	Maintain sorted intervals and use binary search to find insertion/merge positions
TreeMap/Balanced BST (Optimal)	O(log n) per addNum, O(n) per getIntervals	O(n)	Use self-balancing tree structure for O(log n) insertions and automatic sorting

Brute Force (Linear Search & Merge) — Algorithm Steps

Initialize empty list to store intervals
For each addNum(val): check if val extends any existing interval
If val connects multiple intervals, merge them all
If val doesn't connect to any, add new interval [val, val]
Sort intervals by start position for getIntervals()

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with empty interval list

Add First Number

Create first interval [1,1]

Linear Search

Check each existing interval for merge opportunity

Merge & Sort

Combine overlapping intervals and sort result

Code -

solution.c — C

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

typedef struct {
    int** intervals;
    int size;
    int capacity;
} SummaryRanges;

SummaryRanges* summaryRangesCreate() {
    SummaryRanges* obj = (SummaryRanges*)malloc(sizeof(SummaryRanges));
    obj->capacity = 100;
    obj->intervals = (int**)malloc(obj->capacity * sizeof(int*));
    obj->size = 0;
    return obj;
}

void summaryRangesAddNum(SummaryRanges* obj, int value) {
    int** mergedIntervals = (int**)malloc(obj->capacity * sizeof(int*));
    int mergedSize = 0;
    int newStart = value, newEnd = value;
    
    for (int i = 0; i < obj->size; i++) {
        int start = obj->intervals[i][0], end = obj->intervals[i][1];
        if (end + 1 >= value && value >= start - 1) {
            newStart = (start < newStart) ? start : newStart;
            newEnd = (end > newEnd) ? end : newEnd;
        } else {
            mergedIntervals[mergedSize] = obj->intervals[i];
            mergedSize++;
        }
    }
    
    mergedIntervals[mergedSize] = (int*)malloc(2 * sizeof(int));
    mergedIntervals[mergedSize][0] = newStart;
    mergedIntervals[mergedSize][1] = newEnd;
    mergedSize++;
    
    free(obj->intervals);
    obj->intervals = mergedIntervals;
    obj->size = mergedSize;
}

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

int** summaryRangesGetIntervals(SummaryRanges* obj, int* returnSize, int** returnColumnSizes) {
    qsort(obj->intervals, obj->size, sizeof(int*), compare);
    *returnSize = obj->size;
    *returnColumnSizes = (int*)malloc(obj->size * sizeof(int));
    for (int i = 0; i < obj->size; i++) {
        (*returnColumnSizes)[i] = 2;
    }
    return obj->intervals;
}

void summaryRangesFree(SummaryRanges* obj) {
    for (int i = 0; i < obj->size; i++) {
        free(obj->intervals[i]);
    }
    free(obj->intervals);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per addNum, O(n log n) per getIntervals

Each addition requires checking all n existing intervals, getIntervals needs sorting

⚡ Linearithmic

Space Complexity

O(n)

Store up to n disjoint intervals in worst case

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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