Data Stream as Disjoint Intervals - Practice Coding Problems

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]

Time & Space Complexity

Time Complexity

⏱️

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

Tree operations are O(log n), getIntervals needs to collect all intervals

⚡ Linearithmic

Space Complexity

O(n)

TreeMap nodes plus interval storage

⚡ Linearithmic Space

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
✓ 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)	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 — Algorithm Steps

Keep intervals sorted by start position
Use binary search to find insertion point for new value
Check if new value merges with left/right neighbors
Merge adjacent intervals if needed
Shift remaining intervals to maintain sorted order

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Use binary search to find insertion position

Check Neighbors

Check if new value merges with adjacent intervals

Merge Logic

Determine merge boundaries and new interval

Array Shift

Shift elements to maintain sorted order

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 = 1000;
    obj->intervals = (int**)malloc(obj->capacity * sizeof(int*));
    obj->size = 0;
    return obj;
}

int binarySearch(SummaryRanges* obj, int target) {
    int left = 0, right = obj->size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (obj->intervals[mid][0] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

void summaryRangesAddNum(SummaryRanges* obj, int value) {
    int insertPos = binarySearch(obj, value);
    
    int mergeStart = value, startIdx = insertPos;
    if (insertPos > 0 && obj->intervals[insertPos - 1][1] + 1 >= value) {
        mergeStart = obj->intervals[insertPos - 1][0];
        startIdx = insertPos - 1;
    }
    
    int mergeEnd = value, endIdx = insertPos;
    while (endIdx < obj->size && obj->intervals[endIdx][0] <= value + 1) {
        mergeEnd = (obj->intervals[endIdx][1] > mergeEnd) ? obj->intervals[endIdx][1] : mergeEnd;
        free(obj->intervals[endIdx]);  // Free old interval
        endIdx++;
    }
    
    // Free intervals that will be replaced
    for (int i = startIdx; i < endIdx && i != insertPos; i++) {
        if (i < obj->size) free(obj->intervals[i]);
    }
    
    // Shift remaining intervals
    for (int i = endIdx; i < obj->size; i++) {
        obj->intervals[startIdx + 1 + i - endIdx] = obj->intervals[i];
    }
    
    // Insert new merged interval
    obj->intervals[startIdx] = (int*)malloc(2 * sizeof(int));
    obj->intervals[startIdx][0] = mergeStart;
    obj->intervals[startIdx][1] = mergeEnd;
    
    obj->size = obj->size - (endIdx - startIdx) + 1;
}

int** summaryRangesGetIntervals(SummaryRanges* obj, int* returnSize, int** returnColumnSizes) {
    *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(log n) search + O(n) merge/shift = O(n)

Binary search is fast but merging can require shifting all intervals

⚡ Linearithmic

Space Complexity

O(n)

Store up to n intervals in sorted array

⚡ Linearithmic Space

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

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

🌊 Data Stream as Disjoint Intervals

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search Insertion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler