Finding the closest intervals in an interval tree that do not contain the query

Question

I have implemented an Interval Tree in Java as outlined in the CLRS algorithm book (it uses red-black tree as the underlying structure). In the book (and as far as I've seen online), it discusses how to find the node whose interval contains the number being queried.

In my case, if the number being queried does not fall into any interval, I want to know what the 'closest' nodes are, i.e., those whose intervals lie immediately before and immediately after the query. I have accomplished this using the following functions. Each node contains the interval (int low, int high), as well as the min and max values of themselves and their subtrees.

public Node[] findPrevNext(int query) {
    if (tree.root.isNull())
        return null;
    else {
        Node prev = findPrev(query, tree.root, new Node());
        Node next = findNext(query, tree.root, new Node());
        Node[] result = {prev, next};
        return result;
    }
}

private Node findPrev(int query, Node x, Node prev) {
    if (x.interval.high < query && x.interval.high > prev.interval.high)
        prev = x;
    if (!x.left.isNull())
        prev = findPrev(query, x.left, prev);
    if (!x.right.isNull())
        prev = findPrev(query, x.right, prev);
    return prev;
}

private Node findNext(int query, Node x, Node next) {
    if (x.interval.low > query && x.interval.low < next.interval.low)
        next = x;
    if (!x.left.isNull())
        next = findNext(query, x.left, next);
    if (!x.right.isNull())
        next = findNext(query, x.right, next);
    return next;
}

The problem, of course, is that the functions findPrev() and findNext() both traverse the whole tree and don't take advantage of the tree's structure. Is there a way to perform this query in O(lgn) time?

I've also considered the possibility of creating a second Interval Tree which would contain all interval gaps, and simply doing the query on there. The nodes would then contain information about which elements are before and after that gap (I have attempted but as of yet am unsuccessful in implementing this).

Edit: Just to note, the function findPrevNext() is called after attempting to find the query fails. So, the query is known not to fall in any given interval beforehand.

score 1 · Answer 1 · answered May 15 '13 at 04:10

Since the intervals are ordered by low endpoint, above is straightforward – starting from the hole where an interval [query, query] would be, ascend the tree until you reach a parent from its left child; that parent is the desired node.

Below would seem to require inspection of the max fields. Given a subtree containing only intervals below the query, (i.e., those whose lower endpoint is lower than the query) we can extract one candidate for the nearest below by descending on the path whose nodes have the highest value of max. There are O(log n) maximal such subtrees, one for every time in the search algorithm we considered going left but didn’t. We also need to check the O(log n) nodes on the original search path. Naïvely, this idea leads to a O(log² n)-time algorithm, but if we maintain at each node a pointer to one interval whose high equals the max for that node, then we get an O(log n)-time algorithm.

score 0 · Answer 2 · answered May 14 '13 at 20:46

The Java TreeMap, which implements a red-black tree, implements the methods headMap and tailMap that return the portions of the map less than the query point (for headMap) or greater than the query point (for tailMap). If you implement something similar to these methods for your tree then this should allow you to do a linear traversal from the query point to find the N closest intervals, rather than having to traverse the entire tree.

Finding the closest intervals in an interval tree that do not contain the query

2 Answers2