Engineering Fully Dynamic Convex Hulls

Abstract: We present a new fully dynamic algorithm for maintaining convex hulls under insertions and deletions while supporting geometric queries. Our approach combines the logarithmic method with a deletion-only convex hull data structure, achieving amortised update times of $O(\log n \log \log n)$ and query times of $O(\log^2 n)$. We provide a robust and non-trivial implementation that supports point-location queries, a challenging and non-decomposable class of convex hull queries. We evaluate our implementation against the state of the art, including a new naive baseline that rebuilds the convex hull whenever an update affects it. On hulls that include polynomially many data points (e.g. $Θ(n^\varepsilon)$ for some $\varepsilon$), such as the ones that often occur in practice, our method outperforms all other techniques. Update-heavy workloads strongly favour our approach, which is in line with our theoretical guarantees. Yet, our method remains competitive all the way down to when the update to query ratio is $1$ to $10$. Experiments on real-world data sets furthermore reveal that existing fully dynamic techniques suffer from significant robustness issues. In contrast, our implementation remains stable across all tested inputs.

• The paper introduces a fully dynamic convex hull algorithm achieving O(log n log log n) update and O(log^2 n) query times for robust performance.
• The paper employs bucket partitioning with deletion-only data structures and efficient merge operations to maintain high performance in update-heavy scenarios.
• The paper demonstrates practical improvements over prior methods with strong empirical evidence on real-world and synthetic datasets, even under degenerate conditions.

Efficient and Robust Fully Dynamic Convex Hull Data Structures

Introduction

The convex hull problem remains a cornerstone of computational geometry, with fully dynamic variants (supporting arbitrary insertions and deletions along with complex geometric queries) being central to numerous scientific and engineering domains. The explicit maintenance of convex hulls is critical in clustering, shape analysis, data pruning, and query processing over spatial datasets, necessitating highly performant and robust dynamic data structures.

This work introduces an efficient, fully dynamic convex hull algorithm that leverages the logarithmic method for bucketization—combined with deletion-only data structures—facilitating $O(\log n \log \log n)$ amortized update and $O(\log^2 n)$ query times. Notably, the implementation demonstrates strong robustness and computational advantages over existing methods, particularly in update-heavy scenarios and with real-world, degenerate datasets.

State of the Art and Open Challenges

Fully dynamic convex hull maintenance has primarily relied on variants of the Overmars-van Leeuwen CQ-Tree, with theoretical optimality but limited practicality due to pointer-heavy and rotation-based manipulations. Prior work, e.g., Brodal-Jacob, focused on decomposable queries, providing $O(\log n)$ bounds by exploiting the decomposability of certain convex hull queries. However, handling non-decomposable queries such as point location remains challenging.

Recent methods either restrict the update model (e.g., requiring monotone insertions) or fail to scale in the presence of practical degeneracies—duplicate $x$- or $y$-coordinates—ubiquitous in real datasets. Notably, implicit methods, though appealing in theory, have not seen robust practical implementations, given their reliance on intricate structures and assumptions seldom met in real data.

Data Structure Design

The central technical advancement is the adaptation of the logarithmic method to the fully dynamic convex hull setting, informed by three key considerations:

1. Bucket Partitioning with Deletion-Only Hull Structures: The point set is dynamically partitioned into buckets of exponentially increasing sizes, each managed via deletion-only hull data structures (per Chazelle, Hershberger-Suri). Unlike standard logarithmic method implementations, bucket fullness is decoupled from emptiness invariants to flexibly support bulk deletions.
2. Efficient Merge Operations: Bucket merges, triggered by insertions or underflow, are implemented as in-place loser tree merges followed by a linear-time hull construction for sorted data. This retains overall amortized $O(n \log n \log\log n)$ bounds despite non-trivial changes due to deletions.
3. Handling Degeneracies and Non-Decomposable Queries: A dedicated $x$-coordinate dictionary maintains a priority queue for each coordinate, ensuring only the maximal $y$-coordinate point per $x$ is retained, rendering the structure robust to degeneracies. Point location—an archetypal non-decomposable query—is implemented by synthesizing tangent information across buckets, which, unlike previous approaches, is achieved without sacrificing amortized performance.

Theoretical Guarantees

Rigorous amortized analysis demonstrates that both insertion-triggered and deletion-triggered merges, as well as per-operation bucket maintenance, do not exceed $O(n \log n \log\log n)$ total time over $O(\log^2 n)$0 operations, with worst-case query complexity being $O(\log^2 n)$1. The alignment between analytical and observed update costs is particularly strong, as the method frontloads work when required but avoids unnecessary recomputation via flexible bucket management.

Empirical Evaluation

Real-World Data: Robustness and Performance

The method is empirically validated on diverse real-world datasets—3D mammal scans, cluster sets, TIGER spatial features—characterized by duplicate coordinates and frequent degeneracies. Competing fully dynamic implementations consistently crash, leak memory, or produce incorrect results under such scenarios; in contrast, the proposed method maintains correctness and completes all test sequences robustly.

Figure 1: Comparing update times in nanoseconds of competing dynamic convex hull algorithms on representative real-world datasets.

A naïve Semi-Static method (static rebuild upon every update) is competitive when hulls are sparse and datasets small; however, the new fully dynamic method consistently dominates in update-intensive settings or with denser hulls.

Synthetic Data: Structural Sensitivity

On controlled synthetic generators (Box, Bell, Disk, Circle; varying hull sizes from $O(\log^2 n)$2 up to $O(\log^2 n)$3), the update performance gap widens as the expected hull size grows. The new method maintains stable, fast updates regardless of hull density, while query latency exhibits the anticipated $O(\log^2 n)$4 dependence. Notably, alternative state-of-the-art structures become intractable for dense hull scenarios.

Figure 2: Time in nanoseconds per deletion (left) and query (right) across four synthetic distributions; bucket-based methods yield consistent update times even as hull size increases.

Mixed Workloads and Scaling

Evaluation under varying update-to-query ratios (e.g., $O(\log^2 n)$5 for $O(\log^2 n)$6 up to $O(\log^2 n)$7) demonstrates that the method remains preferable so long as queries do not vastly outnumber updates (at least up to $O(\log^2 n)$8 on typical datasets; up to $O(\log^2 n)$9 on Disk distributions).

Figure 3: Mean operation time as query pressure increases relative to updates; the proposed method sustains its dominance until queries heavily outweigh updates.

Scaling experiments (up to $O(\log n)$0) confirm that the method preserves its efficiency advantage even for massive datasets with dense hulls.

Figure 4: Median time per operation under a $O(\log n)$1 workload mix, showing stable scalability for the bucket-based approach across diverse distributions.

Practical Implications

The presented algorithm satisfies stringent requirements for robust, high-performance dynamic convex hulls in applied settings—large-scale spatial analytics, cluster and trajectory analysis, and geometric data-driven ML pipelines. The robust handling of degeneracies, together with amortized near-optimal update costs and practical query support, renders the structure broadly deployable, including as a primitive in extensible computational geometry libraries.

Theoretical Outlook and Future Developments

This work highlights the significant gap between classic theoretical optimality and practical viability in dynamic planar geometry. The flexibility of bucket-based methods with amortized analysis opens further directions:

• Parallel and External-Memory Adaptations: Given the data structure's amenability to cache-friendly vector layouts and bulk operations, adapting the method to parallel or cache-oblivious models could yield further speedup on massive, streaming data.
• Extension Beyond the Plane: The core techniques—flexible bucket management, robust merge, and query composition—could be abstracted for incremental advances in higher-dimensional hulls and related polytope geometric maintenance.
• Learned Augmentations: Integration with learned index structures, as initiated in recent fast search and data reduction schemes, may further accelerate query selectivity within individual buckets.

Conclusion

This paper establishes a new benchmark in the engineering of fully dynamic convex hull data structures, effectively bridging the gap between sophisticated theoretical designs and robust, high-performance practical use. It substantiates both, with strong experimental evidence as well as analytical guarantees, the viability of bucket-based deletion-only structures paired with careful query synthesis. The outcome is a reliable primitive suitable for emerging large-scale spatial analytics and geometric machine learning workloads under adversarial dynamic updates.

Reference: "Engineering Fully Dynamic Convex Hulls" (2604.00271)