U. Glaeser

R-trees
The R-tree of Guttman [104] and its many variants are a practical multidimensional generalization of
the B-tree for storing a variety of geometric objects, such as points, segments, polygons, and polyhedra,
using linear disk space. Internal nodes have degree Θ(B) (except possibly the root), and leaves store Θ(B)
items. Each node in the tree has associated with it a bounding box (or bounding polygon) of all the items
in its subtree. A big difference between R-trees and B-trees is that in R-trees the bounding boxes of sibling
nodes are allowed to overlap. If an R-tree is being used for point location, for example, a point may lie
within the bounding box of several children of the current node in the search. In that case, the search
must proceed to all such children.
In the dynamic setting, several popular heuristics are used to determine to insert new items into an
R-tree and how to rebalance it; see [10,91,99] for a survey. The R∗-tree variant of Beckmann et al. [42]
seems to give best overall query performance. New R-tree partitioning methods by de Berg et al. [68]
and Agarwal et al. [9] provide some provable bounds on overlap and query performance.
In the static setting, in which there are no updates, constructing the R∗-tree by repeated insertions, one
by one, is extremely slow. A faster alternative to the dynamic R-tree construction algorithms mentioned
above is to bulk-load the R-tree in a bottom-up fashion [1,116,159]. The quality of the bottom-up R-tree
in terms of query performance is generally not as good as that of an R ∗ -tree, especially for higherdimensional
data [45,118].
In order to get the best of both worlds—the query performance of R ∗ -trees and the bulk construction
efficiency of Hilbert R-trees—Arge et al. [22] and van den Bercken et al. [193] independently devised
fast bulk loading methods based upon buffer trees that do top-down construction in O(n log m n) I/Os,
which matches the performance of the bottom-up methods within a constant factor. The former method
is especially efficient and supports dynamic batched updates and queries.
Specialized Structures for 2-D Orthogonal Range Search
Diagonal corner 2-sided queries (see Fig. 32.4(a)) are equivalent to stabbing queries, which have the
following form: “Given a set of 1-D intervals, report all the intervals ‘stabbed’ by the query value x.”
(That is, report all intervals that contain x.) A diagonal corner query x on a set of 2-D points {(a 1, b 2),
(a 2, b 2), …} is equivalent to a stabbing query x on the set of closed intervals {[a 1, b 2], [a 2, b 2], …}. Arge
and Vitter [28,199] introduced a new paradigm we call bootstrapping to support such queries in optimal
I/O bounds and space: The data structure uses O(n) disk blocks, queries use O(log B N + z) I/Os, and
updates take O(log B N) I/Os. In another example of bootstrapping, Arge et al. [25] achieve the same
bounds for 3-sided orthogonal 2-D range searching (see Figure 32.4(c)).
The dynamic data structure for 3-sided range searching can be generalized using the filtering technique
of Chazelle [51] to handle general 4-sided queries with optimal I/O query bound O(log B N + z) and
optimal disk space usage O(n(log n)/log (log B N + 1)) [25]. The update bound becomes O((log B N) (log
n)/log (log B N + 1)), which may not be optimal.
Other Types of Range Search
For other types of range searching, such as in higher dimensions and for nonorthogonal queries, different
filtering techniques are needed. So far, relatively little work has been done, and many open problems
remain.
Vengroff and Vitter [196] develop the first theoretically near-optimal EM data structure for static 3-D
orthogonal range searching. They create a hierarchical partitioning in which all the points that dominate
a query point are densely contained in a set of blocks. Compression techniques are needed to minimize disk
storage. With some recent modifications [204], (3 + k)-sided 3-D range queries, where k of the dimensions
(0 ≤ k ≤ 3) have finite ranges, can be done in O(log B N + z) I/Os, which is optimal, and the space usage
is O(n(log n) k+1 /(log(log B N + 1)) k ). The result also provides optimal O(log N + Z)-time query performance
for 3-sided 3-D queries in the (internal memory) RAM model, but using O(N log N) space.
© 2002 by CRC Press LLC