Dynamic k-d Tree: Techniques & Challenges

• Dynamic k-d tree is a mutable multidimensional search structure that supports insertions, deletions, and updates through reconstruction-based maintenance.
• The design incorporates diverse update strategies such as single-tree reconstruction, lazy deletion with periodic rebuilds, and batch-dynamic multi-tree approaches.
• Key challenges include managing split dimension variability and metric mismatches, which necessitate full or partial subtree rebuilds to ensure query accuracy.

A dynamic k-d tree is a mutable $k$-dimensional search structure that supports updates to an evolving point set while attempting to preserve the query efficiency associated with balanced k-d trees. In the contemporary literature, the term does not denote a single canonical design. It covers at least four distinct regimes: single-tree reconstruction-based self-balancing after insertions and deletions; online trees with lazy deletion and periodic rebuilds for data streams; batch-dynamic parallel structures that rebuild affected subtrees or maintain multiple static components; and application-specific incremental trees engineered for robotics or motion planning. Across these regimes, the central difficulty is stable: the split discriminator changes with depth, so AVL- or red-black-style rotations do not directly preserve k-d ordering, and most dynamic designs therefore rely on subtree or whole-tree reconstruction rather than local rotations (Brown, 9 Sep 2025, Brown, 25 Jun 2025, Brown, 2014).

1. Conceptual definition and problem setting

At the problem level, dynamic k-d tree work assumes an evolving multidimensional dataset such as $P=\{P_1,\dots,P_n\}$, $P_i\in\mathbb{R}^D$, together with queries such as exact or approximate $k$-nearest neighbors, range reporting, or range counting (Naim et al., 2021, Men et al., 2024). The dynamic requirement is that points may be inserted, deleted, re-inserted, expired by a sliding window, or updated in batches rather than being given once for a purely static median-split build (Cai et al., 2021, Barboza et al., 1 Jun 2026, Yesantharao et al., 2021).

The literature separates several update models. In streaming classification, the tree is an online index over a sliding window, with new instances appended and expired instances removed or marked inactive (Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026). In robotics, the tree acts as a dynamic spatial map supporting point-wise and box-wise insertion, deletion, re-insertion, and down-sampling (Cai et al., 2021). In shared-memory parallel settings, the tree may support batch insertion and batch deletion while preserving a weight-balanced invariant through partial reconstruction (Men et al., 2024). In multicore database-style settings, dynamicity may be realized by a log-structured set of static balanced k-d trees rather than by one mutable tree (Yesantharao et al., 2021).

A useful high-level distinction is between exact and approximate query semantics. Some systems are explicitly exact and reject approximate nearest-neighbor methods because they may miss true neighbors or introduce nondeterminism in safety-critical settings (Naim et al., 2021). Others are explicitly approximate, especially in data streams, where pruning heuristics and Canberra-distance adaptations are used to reduce processing time with minor loss in average accuracy (Barboza et al., 1 Jun 2026, Barboza et al., 16 Jul 2025).

2. Why dynamic maintenance is difficult

The principal obstruction to classical self-balancing is that a k-d tree uses different comparison keys at successive depths. Brown’s dynamic self-balancing formulation makes this explicit with cyclic “super keys” such as $x\!:\!y\!:\!z$, $y\!:\!z\!:\!x$, and $z\!:\!x\!:\!y$ in 3D, where the node’s validity depends on the split dimension at its depth (Brown, 9 Sep 2025). A rotation moves nodes across depths and therefore across discrimination dimensions, which can destroy the sorted order of the k-d tree (Brown, 9 Sep 2025). Static-build reviews repeat the same point: AVL and red-black techniques are not directly applicable, so balanced k-d trees are normally built by repeated median selection or presorting rather than by local repair (Brown, 25 Jun 2025, Brown, 2014).

The operational consequence is that most dynamic k-d trees are rebuild-oriented. A standard online insertion path can become skewed, causing search performance to degrade from intended near $O(\log n)$ traversal behavior toward $O(n)$ in the worst case (Naim et al., 2021). In streaming settings, repeated insertions and lazy deletions additionally cause stale partitioning and dead-node accumulation (Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026). In robotics, local map edits and box-wise spatial updates can violate both shape balance and deletion cleanliness unless subtree statistics are monitored and rebuilt when thresholds are crossed (Cai et al., 2021).

This difficulty also appears in metric-aware settings. For nonholonomic planning, a classic batch-built kd-tree queried with a sub-Riemannian metric has expected nearest-neighbor complexity

$$\Theta(N^p\log N), \qquad p=\sum_{w_i\le W/k}\left(\frac1k-\frac{w_i}{W}\right), \qquad W=\sum_i w_i,$$

rather than classical logarithmic behavior (Varricchio et al., 2017). That result is not a deletion/insertion theorem, but it shows that even a well-maintained tree can have geometry-induced super-logarithmic search unless split and pruning rules match the metric.

3. Update mechanisms and balance-maintenance strategies

The dominant maintenance strategies can be summarized as follows.

Strategy	Core mechanism	Representative papers
Reconstruction-based single tree	Insert or delete normally, then rebuild an unbalanced subtree	(Brown, 9 Sep 2025, Cai et al., 2021, Men et al., 2024)
Lazy deletion with periodic rebuild	Mark nodes inactive; rebuild when deleted fraction or growth threshold is exceeded	(Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026)
Multi-tree or forest organization	Distribute points across several trees and rebuild smaller components	(Yesantharao et al., 2021, Naim et al., 2021)
Incremental insertion with metric-aware query/build changes	Insert on the fly, but alter split directions or pruning rules to match the metric	(Varricchio et al., 2017)

In Brown’s self-balancing single-tree design, each node stores a height field with

$P=\{P_1,\dots,P_n\}$0

and imbalance is detected on the update path after each insertion or deletion (Brown, 9 Sep 2025). Balance can be tested by a strict or relaxed AVL condition,

$P=\{P_1,\dots,P_n\}$1

or by a red-black-style factor-of-two criterion when both children exist (Brown, 9 Sep 2025). If a node violates the criterion, the entire subtree rooted there is rebuilt as a balanced k-d subtree (Brown, 9 Sep 2025). Deletion is handled by predecessor/successor replacement under the current node’s split dimension rather than by child splicing, because a child belongs to the next discrimination level and cannot simply be promoted (Brown, 9 Sep 2025).

ikd-Tree adopts a related but application-specific policy. Each node stores subtree statistics such as treesize, invalidnum, lazy deletion flags, and a per-dimension bounding box range[k] [2] (Cai et al., 2021). A subtree is monitored by an $P=\{P_1,\dots,P_n\}$2-balanced criterion and an $P=\{P_1,\dots,P_n\}$3-deleted criterion: $P=\{P_1,\dots,P_n\}$4

$P=\{P_1,\dots,P_n\}$5

If either condition is violated, the subtree is flattened, deleted points are discarded, and the subtree is rebuilt (Cai et al., 2021). The paper reports experimental thresholds $P=\{P_1,\dots,P_n\}$6, $P=\{P_1,\dots,P_n\}$7, and a synchronous-versus-asynchronous rebuild cutoff $P=\{P_1,\dots,P_n\}$8 (Cai et al., 2021).

Pkd-tree generalizes partial rebuilding to batch-parallel updates. It maintains a single tree subject to the weight-balance condition

$P=\{P_1,\dots,P_n\}$9

with $P_i\in\mathbb{R}^D$0 in experiments (Men et al., 2024). Update batches are sieved through a tree skeleton; balanced regions recurse, and unbalanced regions stop descending and rebuild the entire affected subtree from exactly the points that should belong there (Men et al., 2024). The paper proves, for batch size $P_i\in\mathbb{R}^D$1, amortized per-element update work $P_i\in\mathbb{R}^D$2 and span $P_i\in\mathbb{R}^D$3 with high probability when

$P_i\in\mathbb{R}^D$4

is used in the sampling-based reconstruction procedure (Men et al., 2024).

Streaming trees favor simpler online maintenance. IncA-DES and the later Online K-d tree use standard insertion, lazy deletion via an active/inactive flag, and rebuilds triggered either when the inactive-node fraction exceeds $P_i\in\mathbb{R}^D$5 or when the tree becomes two times bigger than when it was built (Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026). The recommended practical setting is $P_i\in\mathbb{R}^D$6, with growth-trigger $P_i\in\mathbb{R}^D$7 in the later formulation (Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026). These designs explicitly preserve split-order invariants by not physically unlinking deleted nodes until reconstruction.

4. Query models, exactness, and distance functions

Dynamic k-d trees support multiple query semantics, and the semantics strongly influence maintenance design. Exact nearest-neighbor work emphasizes deterministic traversal, full median recomputation during rebuild, and rejection of $P_i\in\mathbb{R}^D$8-approximate guarantees of the form

$P_i\in\mathbb{R}^D$9

in safety-critical domains (Naim et al., 2021). The deterministic iteratively built kd-tree paper reports that unbalanced trees of 60,000 points were about 23% slower on average than balanced trees for their KNN workload, and it uses periodic rebuilds to restore the intended traversal behavior (Naim et al., 2021).

Approximate streaming trees instead adapt pruning to the chosen distance. The Online K-d tree for data streams uses standard k-d insertion and lazy deletion, but its nearest-neighbor search is approximate because it follows best-first branch recursion and prunes alternate subtrees using split-plane criteria (Barboza et al., 1 Jun 2026). For Euclidean and Manhattan distances, the split criterion is

$k$0

For Canberra distance, the adaptation is

$k$1

The paper reports average neighborhood precision of $k$2 for Euclidean, $k$3 for Manhattan, and $k$4 for Canberra, together with average throughput gains of $k$5, $k$6, and $k$7 over brute-force kNN, respectively (Barboza et al., 1 Jun 2026).

IncA-DES uses a closely related online k-d tree to store the Dynamic Selection Window for dynamic ensemble selection under concept drift (Barboza et al., 16 Jul 2025). It also uses Canberra distance,

$k$8

and a one-dimensional Canberra segment

$k$9

for subtree pruning (Barboza et al., 16 Jul 2025). The paper states that the online k-d tree improved processing time with a negligible loss in accuracy and, at search space size $x\!:\!y\!:\!z$0, increased average throughput from 323 instances/s to 7846 instances/s across Sine, SEA, and Agrawal, with average accuracy changing from $x\!:\!y\!:\!z$1 to $x\!:\!y\!:\!z$2 (Barboza et al., 16 Jul 2025).

Metric mismatch remains a deeper issue even outside streams. For nonholonomic systems, the relevant metric balls are anisotropic weighted boxes rather than Euclidean spheres, and classic coordinate-cycling k-d trees may therefore visit $x\!:\!y\!:\!z$3 leaves in expectation (Varricchio et al., 2017). That paper proposes outer Ball-Box pruning and Lie splitting, in which splitting normals follow privileged directions and their frequencies match the weights of the sub-Riemannian geometry (Varricchio et al., 2017). It is not a full dynamic-maintenance paper, but it is directly relevant to insertion-only dynamic trees used in online planning.

5. Batch-dynamic, parallel, and multi-tree organizations

Dynamic maintenance becomes qualitatively different when updates are parallel or naturally batched. BDL-tree does not maintain one mutable k-d tree; it uses the logarithmic method and keeps a log-structured set of static balanced kd-trees with capacities

$x\!:\!y\!:\!z$4

plus a buffer tree of size $x\!:\!y\!:\!z$5 (Yesantharao et al., 2021). A fullness bitmask $x\!:\!y\!:\!z$6 records occupied levels, and insertion computes

$x\!:\!y\!:\!z$7

to determine which levels must be merged and rebuilt (Yesantharao et al., 2021). For a BDL-tree with $x\!:\!y\!:\!z$8 points, each batch of $x\!:\!y\!:\!z$9 updates takes

$y\!:\!z\!:\!x$0

amortized work and

$y\!:\!z\!:\!x$1

depth (Yesantharao et al., 2021). This design preserves exact k-NN query semantics, but queries must search across several component trees (Yesantharao et al., 2021).

Pkd-tree instead keeps one tree and rebuilds only locally imbalanced subtrees (Men et al., 2024). Its construction and reconstruction are batch-parallel and cache-efficient, using $y\!:\!z\!:\!x$2-level skeletons, sampling, and sieve-based redistribution (Men et al., 2024). The paper reports that, on $y\!:\!z\!:\!x$3 2D points, insertion time for a 1% batch on uniform data was $y\!:\!z\!:\!x$4 s for Pkd-tree, compared with $y\!:\!z\!:\!x$5 s for Log-tree, $y\!:\!z\!:\!x$6 s for BHL-tree, and $y\!:\!z\!:\!x$7 s for CGAL, while deletion time for a 1% batch was $y\!:\!z\!:\!x$8 s, $y\!:\!z\!:\!x$9 s, $z\!:\!x\!:\!y$0 s, and $z\!:\!x\!:\!y$1 s, respectively (Men et al., 2024). The paper summarizes speedups over the fastest baseline Log-tree of roughly $z\!:\!x\!:\!y$2–$z\!:\!x\!:\!y$3 for insertions and $z\!:\!x\!:\!y$4–$z\!:\!x\!:\!y$5 for deletions in the main synthetic experiments (Men et al., 2024).

A different multi-tree idea appears in the deterministic exact-KNN paper, which proposes a “forest of interval kd-trees” intended to reduce rebuild size and rebuild frequency per tree without compromising exactness (Naim et al., 2021). For rebuild threshold $z\!:\!x\!:\!y$6, the proposed minimum number of trees is

$z\!:\!x\!:\!y$7

The preferred architecture stores an array of kd-trees, each with interval-like metadata such as low_value, median_value, and high_value, but no pointers between trees (Naim et al., 2021). The paper explicitly treats this forest as future work and does not provide implemented empirical results for it (Naim et al., 2021).

Reconstruction engines from static-build research are central to all of these dynamic designs. Brown’s presorting algorithm builds a balanced tree in $z\!:\!x\!:\!y$8 time by presorting in all $z\!:\!x\!:\!y$9 cyclic super-key orders and then stable-partitioning the $O(\log n)$0 inactive index arrays around successive medians without further sorting (Brown, 2014). The later review of three balanced-build variants reiterates that practical dynamic maintenance is rebuild-oriented and compares $O(\log n)$1, $O(\log n)$2, and $O(\log n)$3 build kernels for this purpose (Brown, 25 Jun 2025). GPU-oriented work adds a left-balanced complete-tree rebuild method using exactly one int per data point as temporary storage, $O(\log n)$4 iterations, and one parallel sort plus one CUDA per-node update kernel per iteration (Wald, 2022). These are not dynamic update algorithms in themselves, but they provide the reconstruction primitives on which many dynamic trees depend.

6. Scope boundaries, related structures, and unresolved issues

Several recurrent misconceptions are corrected by the literature itself. First, not every adaptive k-d tree is dynamic in the online data-structure sense. Hierarchical k-d tree grids in radiative transfer are adaptive spatial discretizations built once from a known density field; they support recursive refinement but no insertion, deletion, or online maintenance during simulation (1311.0705). Second, not every “dynamic $O(\log n)$5-tree” is a classical binary-splitting k-d tree. Dynamic compressed $O(\log n)$6-trees reinterpret the structure as a dynamic trie over Morton codes in a fixed discrete universe and support insertion and deletion of points in sparse multidimensional relations, but they are compressed digital trees rather than textbook comparison-based k-d trees (Arroyuelo et al., 2019).

A second boundary concerns exactness claims. The deterministic exact-KNN paper repeatedly states exact intent, but its pseudocode resembles a descent scan more than a full classical branch-and-bound nearest-neighbor algorithm, and its forest query procedure selects a single candidate tree rather than merging candidates across multiple overlapping trees (Naim et al., 2021). The paper itself notes that exactness across the whole dataset would need stronger interval-partition assumptions or a multi-tree search strategy (Naim et al., 2021). Streaming Canberra-based trees are more explicit: they are approximate neighborhood-search structures, and their speedups are distribution-dependent (Barboza et al., 16 Jul 2025, Barboza et al., 1 Jun 2026).

The third open issue is theory. Brown’s self-balancing single-tree method gives empirical $O(\log n)$7 total behavior for insertion and deletion when rebalancing is performed, but it does not provide an amortized proof comparable to balanced BST theory (Brown, 9 Sep 2025). ikd-Tree gives a complete time complexity analysis for its intended robotics regime and reports that it consumes only 4% of the running time of a static k-d tree in the cited LiDAR mapping experiments, but its strongest claims are tied to low-dimensional point-cloud mapping rather than arbitrary workloads (Cai et al., 2021). Pkd-tree and BDL-tree provide the strongest formal parallel update bounds, but both are batch-dynamic rather than fully online one-update-at-a-time structures (Men et al., 2024, Yesantharao et al., 2021).

The cumulative picture is therefore precise rather than uniform. A dynamic k-d tree is best understood as a family of mutable spatial search structures that preserve k-d partition invariants under evolving data by reconstruction, lazy invalidation, partial rebuilding, or log-structured batching. Exact single-tree self-balancing by local rotations remains unavailable in the usual AVL/red-black sense, so the field has converged on reconstruction-based maintenance, with substantial variation in whether the target workload is safety-critical exact KNN, streaming approximate neighborhood search, robotics map maintenance, or batch-parallel multidimensional indexing (Brown, 9 Sep 2025, Cai et al., 2021, Men et al., 2024, Yesantharao et al., 2021).