---
title: Dynamic Planar Convex Hull
url: https://www.emergentmind.com/topics/dynamic-planar-convex-hull
type: topic
---

# Dynamic Planar Convex Hull

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 [1702.03008][2310.18068][1902.11169].

## 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 [1702.03008][2310.18068].

**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 [1702.03008][2310.18068].

### 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 [2310.18068].

### 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 [2403.05697].

## 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)$ [2310.18068][1902.11169].
- **Tangent query:** Find tangents from $q$ to $\mathrm{CH}(P)$, via geometric search and hull annotation [1902.11169].
- **Segment-hull intersection, neighbor queries:** Supported by explicit or tree-based indexing on hull vertices [2310.18068].
- **Point-in-hull membership:** Search for edge spanning $q.x$ in $O(\log n)$, then orientation predicate [2310.18068].
- **Full hull reporting:** Output hull vertices in $O(h+\log n)$ or $O(h)$ [2403.05697].

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 [2310.18068].

## 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 [1902.11169]  | $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)}$ [1902.11169]. 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 [2403.05697].

## 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 [1702.03008].

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 [2310.18068].

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 [1702.03008].

## 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 [2310.18068].
- 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 [1702.03008].

## 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 [2403.05697].
- 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 [2403.05697].

---

**References**

- "Finer-grained Locking in Concurrent Dynamic Planar Convex Hulls" [1702.03008]
- "Simple and Robust Dynamic Two-Dimensional Convex Hull" [2310.18068]
- "Dynamic Planar Convex Hull" [1902.11169]
- "Dynamic Convex Hulls for Simple Paths" [2403.05697]

Source: https://www.emergentmind.com/topics/dynamic-planar-convex-hull