Space-Filling Curves: Theory & Applications

Updated 7 February 2026

Space-filling curves are continuous, surjective mappings from a one-dimensional domain onto multidimensional regions, preserving spatial locality.
They are constructed using methodologies such as bit interleaving and recursive subdividing techniques (e.g., Hilbert, Peano, Morton) and are applied in databases, scientific computing, and parallel processing.
Recent advances include adaptive, learned, and piecewise variants that optimize clustering performance and handle workload skew in complex, high-dimensional datasets.

A space-filling curve (SFC) is a continuous, surjective mapping from a one-dimensional domain (typically an interval or discrete set) onto a multidimensional region, such as [0,1]^d or a finite grid. Classical examples include the Hilbert, Peano, and Morton (Z-order) curves. SFCs transform the problem of multidimensional locality into a linear order, enabling the application of efficient one-dimensional indexing, partitioning, and access methods in computational geometry, databases, scientific computing, and high-performance parallel processing (Liu et al., 2023).

1. Formal Definitions and Classical Constructions

A classical SFC σ is a mapping σ: [0…2^{{ℓ}-1]^d} → [0…2^{dℓ}-1] that visits every cell of a d-dimensional ℓ-bit grid exactly once (Liu et al., 2023). The mapping is typically defined by interleaving bits of the coordinates of each point (Morton, Z-order curve) or via recursive, orientation-sensitive rules (Hilbert, Peano).

Hilbert curve: Defined recursively, each order-k Hilbert curve replaces the segments of the order-(k–1) curve with rotated/reflected mini-curves, yielding a continuous path filling the square or cube, with superior locality-preservation. In 2D, its algebraic description uses Gray-codes and bitwise operations (Liu et al., 2023, Kanungo, 2024).
Peano curve: Uses a ternary rather than binary subdivision, constructed via a self-similar recursive pattern that subdivides each cell into 3^d parts at each level (Kanungo, 2024).
Morton (Z-order) curve: Orders points by interleaving the bits of each coordinate, offering computational simplicity but suboptimal locality compared to Hilbert or Peano (Liu et al., 2023, Jasrasaria et al., 2016).
Lebesgue curve: Generalizes Z-order to higher order substitutions—mapping from the Cantor set is extended piecewise-linearly to the unit interval (Ozkaraca, 2022, Kanungo, 2024).

The Hausdorff dimension of any non-degenerate SFC is d, with global Hölder continuity exponent 1/d or better (Hilbert: exponent 1/2 in 2D) (Kanungo, 2024). No SFC is injective; bijective mappings exist only at the discrete level.

2. Locality, Clustering, and Algorithmic Implications

The central motivation for SFCs in algorithms is locality preservation: if points are close in d-space, they tend to be close on the curve; this minimizes cache misses, I/O, and communication when the data or computation is linearized.

Clustering Number: For a region q, the clustering number c(q,σ) is the number of contiguous intervals in the SFC-indexed array required to cover q. The average clustering for a query set Q is c(Q,σ) = (1/|Q|) Σ_{q∈Q} c(q,σ) (Xu et al., 2018).
Optimality: No single SFC is optimal for all possible query shapes. The onion curve achieves a provable constant-factor approximation to the minimum achievable clustering on cube and near-cube queries, uniformly over all sizes—this distinguishes it from the Hilbert and Morton curves, which can be far from optimal for large cubes (Xu et al., 2018).
Computational Cost: Morton code evaluation can be O(1), Hilbert typically O(ℓ) bit-manipulations per point, but both are extremely efficient for large grids (Liu et al., 2023).
Neighbor-finding: Efficient O(1)-average neighbor-finding algorithms exist for regular grids using SFCs (Hilbert, Peano, Sierpiński), via grammar-and-matrix models leading to compact lookup-tables (Holzmüller, 2017).

3. Adaptive, Piecewise, and Learned SFCs

Recent work addresses the limitations of fixed SFCs by introducing workload- and data-adaptive SFCs:

BMTree (Bit Merging Tree): Partitions the data space adaptively into subspaces, each with its own locally optimized SFC mapping. Tree construction is formulated as an MDP, with MCTS-guided learning, and supports partial retraining on data/query-shift (Li et al., 3 May 2025).
Learned Monotonic SFC (LMSFC): Uses a discrete parameterization of bit interleaving, optimizes via Sequential Model-Based Optimization (offline), and supports query-time range splitting. This allows the SFC to be adapted to workload—reducing average query time by 2–4× compared to fixed Z-order or Hilbert, with speedup increasing in dimension (Gao et al., 2023).
Reinforcement-Learned SFCs: Bit-merging pattern search is cast as an RL problem (LBMC), with stepwise O(1)-cost evaluation of block scan and cluster counts for each pattern, enabling large-scale selection in nearly linear time (Liu et al., 2023).
Scaled Gray–Hilbert Index: Adapts the depth of Hilbert-style subdivision locally to achieve load balancing or index compactness in high dimensions, offering dramatic space savings (up to 99% over global static trees) and near-constant query time (Jahn et al., 2019).
Data-driven and neural SFCs: Constructed by optimizing a weighted sum of data-feature and spatial-locality criteria, learned via graph neural networks or supervised surrogate modeling; outperforms or matches classical SFCs in specific vision and visualization applications (Wang et al., 2022, Zhou et al., 2020).

These approaches enable SFCs to address workload skew, anisotropic queries, and non-uniform data distributions, solving a major limitation of classical curves.

4. Applications in Scientific Computing, Databases, and Machine Learning

SFCs are central to various computational and data-science workloads:

Parallel mesh partitioning: Hilbert and scaled Gray–Hilbert indices support low-communication, load-balanced partitioning for adaptive and regular meshes; SFC-induced partitions have provably bounded surface-to-volume ratios even on adaptive Cartesian grids (Gadouleau et al., 2021, Liu et al., 2017, Jahn et al., 2019).
Spatial databases: SFCs linearize multidimensional data for one-dimensional B+-tree or similar index structures, supporting efficient multidimensional range and k-NN queries; learned/piecewise SFCs yield substantial I/O and latency improvements in real datasets (Liu et al., 2023, Li et al., 3 May 2025, Gao et al., 2023).
Convolutional neural networks on unstructured meshes: By reordering mesh nodes/cells using an SFC-induced permutation, multi-dimensional unstructured data is transformed into a 1D array for direct application of classic 1D CNNs, with multiple SFCs further enhancing locality (Heaney et al., 2020).
Matrix multiplication: Generalized Hilbert SFCs partition the computational domain in GEMM to maximize data locality and minimize bandwidth, yielding a single compact, platform-agnostic kernel that matches or exceeds the performance of hand-tuned vendor libraries (Georganas et al., 22 Jan 2026).
Machine learning for chemistry: Morton SFC-based structural embeddings (SFC-M family) convert 3D molecular/crystal geometries and atomic descriptors to sparse vectors for neural property prediction, preserving spatial and chemical locality (Jasrasaria et al., 2016).

5. Generalizations and Theoretical Properties

SFCs can be constructed for arbitrary d ≥ 2, arbitrary grid sizes, and a spectrum of subdivision rules:

Pandimensional and substitution-generated SFCs: Serpentine Hamiltonian recurrences and tile-substitution formalisms yield a general framework for constructing SFCs of arbitrary rank, including Peano, Hilbert, Fibonacci, Lebesgue, and their variants (Jaffer, 2014, Ozkaraca, 2022, Ozkaraca, 2024).
Self-similarity, measure, and regularity: Classical SFCs are self-affine or self-similar, typically measure-preserving on the unit square (e.g., Lebesgue curve), with Hölder continuity exponent 1/d (Kanungo, 2024, Ozkaraca, 2022). The Fibonacci SFC, constructed by substitution tiling via the Cartesian product of the Fibonacci substitution, is distinct in scaling ratio (φ, the golden ratio) and tile sequence (Ozkaraca, 2024).
Topological universality: The Hahn–Mazurkiewicz theorem asserts that a set A⊂ℝⁿ is the continuous image of [0,1] if and only if it is compact, connected, and weakly locally connected. Thus, space-filling curves exist for any such set and provide an explicit (albeit typically non-injective) surjection (Kanungo, 2024).

6. Modern Variants and Contextual SFCs

Contemporary research has introduced a diversity of SFCs and related ordering strategies to meet specialized locality/clustering, workload, or data adaptation objectives:

Onion curve: Offers provably near-optimal clustering for cube and near-cube query sets, outperforming Hilbert in high-dimensional regimes with large cube queries (Xu et al., 2018).
Aztec curve: Defined by a 16-fold recursive grammar, accommodates certain bi-dimensional clusters (e.g., 3×3 contiguous blocks) not possible in Hilbert/Peano, relevant for applications like compressed sensing. However, analytical locality/cluster performance is not documented in the data (Ayala et al., 2022).
Generalized and scaled Gray–Hilbert curves: Allow for both arbitrary aspect ratios and locally adaptive refinement, critical for large-scale and high-dimensional data (Jahn et al., 2019).
Piecewise SFCs: Assign different bit-merging rules to different data subspaces (BMTree), addressing spatial skew and query anisotropy in workload-aware fashion (Li et al., 3 May 2025).
Neural/data-driven SFCs: Leverage supervised or unsupervised learning to infer a scan order tailored to data content, yielding superior performance in vision and compression tasks (Wang et al., 2022, Zhou et al., 2020).

7. Summary of Advantages, Limitations, and Research Directions

SFCs provide an algorithmically and analytically tractable means to linearize multidimensional data, preserving a strong degree of spatial locality. Their strengths include:

Locality enhancement for 1D data structures.
Efficient, scalable construction, neighbor-finding, and partitioning algorithms.
Provably optimal or nearly optimal clustering (onion, learned, or piecewise SFCs) for certain workloads or query shapes.
Applicability to adaptive, high-dimensional, and hierarchical data structures (scaled Gray–Hilbert, BMTree).
Extensibility to neural/data-driven constructions where global geometry or semantic consistency are important.

Limitations and open problems include:

No single static SFC is universally optimal for all query workloads, shapes, or data distributions (Li et al., 3 May 2025, Liu et al., 2023).
Classical SFCs may perform poorly for extreme aspect ratio or highly skewed queries unless adaptively tuned.
There is a substantial offline/learning cost for workload-tuned or neural SFCs, though this is amortized over query cost (Gao et al., 2023, Liu et al., 2023).
Analytical understanding of clustering/locality for recent SFC variants (e.g., Aztec, neural) is limited.
Extension to arbitrary topologies, irregular geometries, or domains with complex boundaries remains active research (Heaney et al., 2020, Ozkaraca, 2022).

Space-filling curves continue to play a foundational role in multidimensional data management, geometric algorithms, and high-performance computation, with ongoing research focusing on adapting their structure to empirical data distributions, workloads, and hardware platforms.