Algorithms and Data Structures for External Memory

104 Spatial Data Structures and Range Search
The rebalancing heuristics perform well in many practical scenarios,
especially in low dimensions, but they result in poor worst-case
query bounds. An interesting open problem is whether nontrivial query
bounds can be proven for the “typical-case” behavior of R-trees for
problems such as range searching and point location. Similar questions
apply to the methods discussed in Section 12.1. New R-tree partitioning
methods by de Berg et al. [128], Agarwal et al. [17], and Arge et al. [38]
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, 206, 276].
Such methods use some heuristic for grouping the items into leaf nodes
of the R-tree, and then recursively build the nonleaf nodes from bottom
to top. As an example, in the so-called Hilbert R-tree of Kamel
and Faloutsos [206], each item is labeled with the position of its centroid
on the Peano-Hilbert space-filling curve, and a B + -tree is built
upon the totally ordered labels in a bottom-up manner. Bulk loading
a Hilbert R-tree is therefore easy to do once the centroid points
are presorted. These static construction methods algorithms are very
different in spirit from the dynamic insertion methods: The dynamic
methods explicitly try to reduce the coverage, overlap, or perimeter of
the bounding boxes of the R-tree nodes, and as a result, they usually
achieve good query performance. The static construction methods do
not consider the bounding box information at all. Instead, the hope
is that the improved storage utilization (up to 100%) of these packing
methods compensates for a higher degree of node overlap. A dynamic
insertion method related to [206] was presented in [207]. The quality
of the Hilbert R-tree in terms of query performance is generally
not as good as that of an R*-tree, especially for higher-dimensional
data [84, 208].
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. [41] and van den Bercken et al. [333] independently devised
fast bulk loading methods based upon buffer trees that do top-down
construction in O(nlog m n) I/Os, which matches the performance of