Dynamic Planar Convex Hull

• Dynamic planar convex hull is a data structure that maintains the minimal convex polygon of a dynamic set in R² using efficient INSERT and DELETE operations.
• It leverages the Overmars–van Leeuwen framework with balanced BSTs and merge routines to achieve O(log² n) amortized update time and O(log n) query time.
• Recent enhancements include a 3-case bridge-finding method and concurrent locking strategies that improve performance and practical throughput.

A dynamic planar convex hull data structure maintains the convex hull $\mathrm{CH}(P)$ of a dynamically changing set $P \subset \mathbb{R}^2$, supporting efficient INSERT, DELETE, and various query operations. Owing to the foundational work of Overmars and van Leeuwen, and substantial subsequent advances, the problem integrates geometric, data-structural, and algorithmic principles. This entry details the main theoretical models, algorithmic structures, practical optimizations, lower bounds, and variants motivated both by theory and applications.

1. Problem Definition and Historical Context

The dynamic planar convex hull problem concerns the efficient maintenance of the minimal convex polygon $\mathrm{CH}(P)$ containing a point set $P \subset \mathbb{R}^2$, under arbitrary sequences of insertions and deletions of points. Core operations include:

• $\mathrm{INSERT}(p)$, $\mathrm{DELETE}(p)$, maintaining $P$;
• Query operations: extreme point in direction $d$, tangent through $q$, intersection/bridge, neighbor on hull, point-in-hull membership, and full hull reporting.

The classic Overmars-van Leeuwen framework achieves $O(\log^2 n)$ amortized update time with $O(\log n)$ query costs, using a balanced BST with partial hulls stored at internal nodes. Subsequent work has yielded improvements for specialized models and queries, but worst-case $O(\log^2 n)$ update persists in fully general settings unless one resorts to randomized or output-sensitive bounds (Mills et al., 2017, Gæde et al., 2023, Jacob et al., 2019).

2. Algorithmic Structures and Core Principles

2.1. Overmars-van Leeuwen Hull Trees and Variants

The foundational “HullTree” is an external leaf-based balanced BST, with each internal node $u$ maintaining:

• pointers to two child nodes,
• two convex-hull chains $L_u$ (left) and $R_u$ (right), typically according to a vertical split, updated via a merge routine,
• a minY (or minX) augmentation for search routing.

Update workflow: Insertion or deletion of a point triggers a descent to a relevant leaf, structural modification (splitting or splicing), and an upward pass of chain-merging. The merge procedure uses the classical bridge-finding (tangent identification) between two convex chains, based on Overmars & van Leeuwen’s algorithm (Mills et al., 2017, Gæde et al., 2023).

Complexity: Each update performs $O(\log n)$ BST operations (search/split/splice) and $O(\log n)$ chain merges, each costing up to $O(\log n)$ total since the size of hulls at level $i$ is $O(n/2^i)$ and $\sum_i h_i = O(\log n)$. Thus, $O(\log^2 n)$ amortized per update (Mills et al., 2017, Gæde et al., 2023).

2.2. Algorithmic Simplification: 3-Case Bridge-Finding

Recent advances reduce the classical 11-case bridge-finding test to a 3-case formulation, expressible as:

1. Discard right part of chain $CH^+(\pi(x))$ if $$\operatorname{slope}(\alpha) \leq \operatorname{slope}(lr)$$,
2. Discard left part of $CH^+(\pi(y))$ if $$\operatorname{slope}(lr) \leq \operatorname{slope}(\beta)$$,
3. Else, compare intersection $\gamma$ with separator $x_0$ to decide branch. This test accelerates bridge identification and simplifies code, typically described in $<$20 lines of C-style pseudocode (Gæde et al., 2023).

2.3. Rank-Based and Path-Constrained Variants

For rank-ordered data, insertions may non-locally shift $x$-coordinates. Parameterizing bridges with implicit rank-based endpoints and storing “widths” allows efficient $O(\log^2 n)$ updates without extra navigation cost. “Simple path” and “monotone path” restrictions—where updates are allowed only at the path ends—admit $O(1)$ worst-case update time with $O(\log n)$ or $O(\log h)$ queries, using four-list decompositions and specialized partitions (Brewer et al., 2024).

3. Query Capabilities and Functional Extensions

Standard data structures support:

• Extreme-point query: $\arg\max_{p \in P} \langle p, d \rangle$, via duality and interval trees or search on explicit hulls, in $O(\log n)$ or $O(\log h)$ (Gæde et al., 2023, Jacob et al., 2019).
• Tangent query: Find tangents from $q$ to $\mathrm{CH}(P)$, via geometric search and hull annotation (Jacob et al., 2019).
• Segment-hull intersection, neighbor queries: Supported by explicit or tree-based indexing on hull vertices (Gæde et al., 2023).
• Point-in-hull membership: Search for edge spanning $q.x$ in $O(\log n)$, then orientation predicate (Gæde et al., 2023).
• Full hull reporting: Output hull vertices in $O(h+\log n)$ or $O(h)$ (Brewer et al., 2024).

Support for specialized queries such as segment-hull intersection, hull–hull interactions, rank-based queries, and bridge finding is grounded in the explicit storage of partial and global hulls at BST nodes, augmented by geometric predicates evaluated with exact arithmetic for robustness (Gæde et al., 2023).

4. Complexity Bounds and Lower Bounds

Approach/Model	Update time	Query time	Space
Overmars–van Leeuwen [OvL]	$O(\log^2 n)$	$O(\log n)$	$O(n)$
Jacob–Brodal (Jacob et al., 2019)	$O(\log n)$ am	$O(\log n)$	$O(n)$
Simple/monotone path	$O(1)$ wc	$O(\log n)$, $O(\log h)$	$O(n)$
Concurrent (fine/finer lock)	$O(\log^2 n)$ amortized	$O(1)$ (ref query)	$O(n)$

am = amortized, wc = worst-case.

Lower bounds: Any semidynamic hull data structure with amortized query time $q(n)$ must have update cost $I(n) \geq 2^{\Omega(\log(n/q(n)))}$. For $q(n)=O(\log n)$, one must pay $I(n)=2^{\Omega(\log n)}$ (Jacob et al., 2019). Path-constrained models (monotone or simple path) achieve $O(1)$ worst-case updates but must have $O(\log n)$ per hull query, with matching decision-tree lower bounds (Brewer et al., 2024).

5. Concurrency, Robustness, and Implementation

Concurrent dynamic planar convex hulls employ lock-based schemes on BST nodes. Fine-grained locking uses one lock per node, achieving serializability. Finer-grained locking uses two locks (left/right chains) per node, enabling higher throughput—empirically $8$–$60$\% over fine-grained, and $38$–$61\times$ over coarse locking or STM (Mills et al., 2017).

Robust dynamic hulls require exact arithmetic for geometric predicates (orientation, intersection, slope comparisons), achievable via filtered-exact or rational kernels (e.g., CGAL CORE), to handle degeneracies and collinearities. Approximate/float-precision variants may observe 2–4$\times$ speedup but risk correctness for near-degenerate sets (Gæde et al., 2023).

Implementation optimizations include object reuse for node-local buffers, early termination during merge-updates if hull chains remain unchanged, optimistic lock-free search with validation, and JVM/GC tuning for reduced overhead (Mills et al., 2017).

6. Experimental Performance and Practical Considerations

Empirical evaluation on $n\approx 10^6$ points and realistic query/update workloads indicates:

• Simplified algorithms (3-case bridge-finding) yield at least $2\times$ speedup over classical approaches.
• The “Eilice” variant, omitting concatenable queues, achieves running times within $10$–$20$\% of explicit hull-maintaining structures.
• Dynamic hull data structures outperform static reconstructions for nontrivial query workloads ($>100$ queries per block extension of $50\,000$ points), with dynamic build times $0.5$–$0.7$s for $n=1{,}048{,}576$ in exact mode (Gæde et al., 2023).
• In the concurrent setting, on 24-thread hardware, finer-grained approaches reach $1.8$M ops/sec for mixed queries, versus $30$k for coarse/STM. Dynamic hull queries on static sets are $2$–$4\times$ faster than parallel divide-and-conquer (Mills et al., 2017).

7. Model Variants and Theoretical Extensions

Restricting update operations to structured inputs (monotone or simple paths) enables breaking the general $\Omega(\log n)$ update/query barrier. For:

• One-sided monotone paths (stack convex hull): fully dynamic hull with $O(1)$ update and $O(\log h)$ query time.
• Deque updates (both ends): $O(1)$ update, $O(\log n)$ query, $O(h+\log n)$ hull reporting (Brewer et al., 2024).
• Simple paths: $O(1)$ update by partitioning into stack-trees and finger/BST subcomponents.

These results are provably optimal under the algebraic decision-tree model. A plausible implication is that dynamic convex hull algorithms may be tuned for application-specific update models to bypass lower bounds inherent in the fully general problem, trading off flexibility for speed (Brewer et al., 2024).

---

References

• "Finer-grained Locking in Concurrent Dynamic Planar Convex Hulls" (Mills et al., 2017)
• "Simple and Robust Dynamic Two-Dimensional Convex Hull" (Gæde et al., 2023)
• "Dynamic Planar Convex Hull" (Jacob et al., 2019)
• "Dynamic Convex Hulls for Simple Paths" (Brewer et al., 2024)