![]() |
VOOZH | about |
You are given a set of intervals, where each interval contains two variables, low and high, that defines the start and end time of the interval. The task is perform the following operations efficiently:
Table of Content
The idea is to augment a self-balancing Binary Search Tree (BST) called Interval Tree similar to Red Black Tree, AVL Tree, etc to maintain set of intervals so that all operations can be done in O(log n) time.
Every node of Interval Tree stores following information.
- i: An interval which is represented as a pair [start, end]
- max: Maximum high value in subtree rooted with this node.
The low value of an interval is used as key to maintain order in BST. The insert and delete operations are same as insert and delete in self-balancing BST used.
Following is algorithm for searching an overlapping interval x in an Interval tree rooted with root:
- If x overlaps with root's interval, return the root's interval.
- If left child of root is not empty and the max in left child is greater than x's low value, recur for left child
- Else recur for right child.
Let the interval to be searched be x. We need to prove this in for following two cases:
Case 1: When we go to right subtree, one of the following must be true.
- There is an overlap in right subtree: This is fine as we need to return one overlapping interval.
- There is no overlap in either subtree: We go to right subtree only when either left is NULL or maximum value in left is smaller than x.low. So the interval cannot be present in left subtree.
Case 2: When we go to left subtree, one of the following must be true.
- There is an overlap in left subtree: This is fine as we need to return one overlapping interval.
- There is no overlap in either subtree: This is the most important part. We need to consider following facts:
The operations work same as Binary Search Tree (BST) insert and delete operations as a Segment tree is mainly a BST
Inorder traversal of constructed Interval Tree is [5, 20] max = 20 [10, 30] max = 30 [12, 15] max = 15 [15, 20] max = 40 [17, 19] max = 40 [30, 40] max = 40 Searching for interval [6,7] Overlaps with [5, 20]
Time Complexity: O(n*h), where n is the number of intervals, and h is the height of Interval Tree. In average cases, h = log (n) and the time complexity will be O(n * log(n)). In the worst case, the tree will be skewed and the height will be n, thus the time complexity will be O(n ^ 2). If Interval Tree is made self-balancing like AVL Tree, then time complexity reduces to O(n * log n).
Space Complexity: O(n + h), to store the n intervals, and considering the recursive call stack which can be O(h).
Interval tree is mainly a geometric data structure and often used for windowing queries, for instance, to find all roads on a computerized map inside a rectangular viewport, or to find all visible elements inside a three-dimensional scene
Both segment and interval trees store intervals. Segment tree is mainly optimized for queries for a given point, and interval trees are mainly optimized for overlapping queries for a given interval.
Interval trees are a type of data structure used for organizing and searching intervals (i.e., ranges of values). The following are some of the operations that can be performed on an interval tree:
In addition to these basic operations, interval trees can be extended to support more advanced operations, such as searching for intervals with a specific length, finding the closest intervals to a given point, and more. The choice of operations depends on the specific use case and requirements of the application.