Simpler is Faster: Practical Distance Reporting by Sorting Along a Space-Filling Curve

2025-08-27

AI Summary

This paper addresses the distance reporting problem in computational geometry: given a point set $P$, a query point $q$, and a radius $delta$, efficiently report all points $p in P$ satisfying $|p - q| leq delta$. We propose a lightweight method based on space-filling curves (e.g., Hilbert curves): by sorting $P$ along the curve, each distance query reduces to at most four contiguous range scans—eliminating the need for complex index structures such as k-d trees or R-trees. Our key contribution is demonstrating that the inherent locality-preserving property of space-filling curves alone suffices for high-performance querying: in static settings, our approach achieves asymptotically optimal range-reporting efficiency; in dynamic settings, it significantly outperforms traditional indexes, supporting efficient insertions/deletions with minimal maintenance overhead. Experimental evaluation confirms high throughput and low latency across diverse data distributions.

Technology Category

• Search and Optimization: Distributed Search
• Knowledge Representation and Reasoning: Geometric, Spatial, and Temporal Reasoning
• Planning, Routing, and Scheduling: Optimization of Spatio-temporal Systems

Application Category

• Graph Algorithms and Modeling for the Web: Querying, indexing, and retrieval in Web-related graphs
• Search and Retrieval-Augmented AI: Web evaluation methodologies and metrics
• Security and Privacy: Large-scale security measurements

Abstract

Range reporting is a classical problem in computational geometry. A (rectangular) reporting data structure stores a point set $P$ of $n$ points, such that, given a (rectangular) query region $Δ$, it returns all points in $P cap Δ$. A variety of data structures support such queries with differing asymptotic guarantees such as $k$-d trees, range trees, $R$-trees, and quadtrees. A common variant of range queries are distance reporting queries, where the input is a query point $q$ and a radius $δ$, and the goal is to report all points in $P$ within distance $δ$ of $q$. Such queries frequently arise as subroutines in geometric data structure construction and in Fréchet distance computations. Modern implementations typically reduce distance queries to rectangular range queries using the data structures listed above. We revisit a simple and practical heuristic for distance reporting. The approach is straightforward: sort the input point set $P$ along a space-filling curve. Queries then reduce to scanning at most four contiguous ranges along the sorted curve. We show extensive experimental evaluation of modern distance and range reporting data structures. In a static scenario, we show that this simple technique is competitive with all but the most highly optimised range reporting data structures. Notably, these involved structures use space-filling curves themselves to speed up computation. In a dynamic setting, our simpler method even becomes the preferred technique. This leads to a perhaps unexpected insight: while modern data structures invest heavily in leveraging space-filling curves for optimising their layout and traversal, it is the curve itself, rather than the surrounding machinery, that delivers much of the performance.

Problem

• Efficiently reporting points within distance queries
• Comparing space-filling curve sorting to complex structures
• Evaluating static and dynamic geometric query performance

Innovation

• Sorting points along space-filling curve
• Reducing queries to four contiguous ranges
• Using scanning instead of complex structures