Interval Tree - Problem

Implement an interval tree data structure that efficiently finds all intervals that overlap with a given query interval.

An interval is represented as [start, end] where both start and end are integers. Two intervals [a, b] and [c, d] overlap if they have at least one point in common: max(a, c) ≤ min(b, d).

Your task is to implement an IntervalTree class with the following methods:

IntervalTree(intervals): Constructor that builds the tree from a list of intervals
query(queryInterval): Returns all intervals that overlap with the given query interval

Input & Output

Example 1 — Basic Overlapping Intervals

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

› Output: [[2,6]]

💡 Note: Only [2,6] overlaps with [4,8] because max(2,4)=4 ≤ min(6,8)=6. The intervals [1,3], [8,10], and [15,18] do not overlap with [4,8].

Example 2 — Multiple Overlaps

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

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

💡 Note: All three intervals overlap with [2,5]: [1,4] overlaps at [2,4], [2,3] is completely contained, and [5,7] overlaps at point 5.

Example 3 — No Overlaps

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

› Output: []

💡 Note: Neither [1,2] nor [3,4] overlaps with [5,6] since there are no common points between them.

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
queryInterval.length == 2
-10⁶ ≤ start_i, end_i, queryStart, queryEnd ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is augmenting a binary search tree with maximum endpoint information to enable efficient pruning. The interval tree approach achieves O(log n + k) query time by eliminating subtrees that cannot contain overlaps. Time: O(log n + k), Space: O(n)

Common Approaches

✓ Brute Force Linear Search

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

Simply iterate through all intervals and test each one for overlap with the query interval using the overlap condition: max(a,c) <= min(b,d).

Interval Tree with Binary Search

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

Construct a binary search tree where each node stores an interval and maintains the maximum endpoint in its subtree. This allows efficient pruning during search.

Brute Force Linear Search — Algorithm Steps

Step 1: Iterate through all intervals in the list
Step 2: For each interval, check if it overlaps with query interval
Step 3: Add overlapping intervals to result list

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with first interval [1,3]

Check

Test overlap with query [4,8]: max(1,4)=4, min(3,8)=3, 4>3 so no overlap

Continue

Move to next interval and repeat until all checked

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int** solution(int** intervals, int intervalsSize, int* queryInterval, int* returnSize) {
    int** result = malloc(intervalsSize * sizeof(int*));
    int count = 0;
    
    for (int i = 0; i < intervalsSize; i++) {
        // Check if intervals overlap: max(start1, start2) <= min(end1, end2)
        if (max(intervals[i][0], queryInterval[0]) <= min(intervals[i][1], queryInterval[1])) {
            result[count] = malloc(2 * sizeof(int));
            result[count][0] = intervals[i][0];
            result[count][1] = intervals[i][1];
            count++;
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    // Simplified parsing for C - assume small input
    int intervals[10][2] = {{1,3},{2,6},{8,10},{15,18}};
    int queryInterval[2] = {4,8};
    int intervalsSize = 4;
    int returnSize;
    
    int** result = solution((int**)intervals, intervalsSize, queryInterval, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must check every interval in the list for overlap

⚡ Linearithmic

Space Complexity

O(k)

Only store the k overlapping intervals in result list

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~35 min Avg. Time

892 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

Interval Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler