Merger Data Structures

• Merger data structures are algorithmic frameworks designed to efficiently merge overlapping datasets, trees, arrays, and graphs while supporting dynamic operations like split, search, and aggregation.
• They are applied in diverse fields such as text indexing, compressed search, parallel sorting, and astrophysics, offering practical solutions for complex data manipulations.
• Advanced methodologies like gap-weighted biased skip lists, treaps, and partitioning algorithms are employed to achieve optimal merge performance under challenging operational constraints.

A merger data structure is any data organization or algorithm whose central functionality is the merging of sets, trees, arrays, summaries, graphs, or more general structures, often in contexts where merge operations must be efficient, correct under nontrivial overlap semantics, and compatible with additional dynamic operations such as split, search, union, or aggregation. Merger data structures pervade areas from text indexing and compressed data search to parallel sorting, persistent data models, distributed aggregation, graph algorithms, geometric modeling, and astrophysics. Technical challenges arise in supporting arbitrarily interleaved merges, minimizing space and time under concurrency, ensuring compositional merge algebra, and supporting merge in the presence of overlapping, persistent, or versioned data.

1. Mergeable Dictionaries, Heaps, and Trees

The prototypical merger data structure is the mergeable dictionary, which maintains a dynamic collection of subsets from a totally ordered universe under merge, split, search, and related operations. The canonical difficulty is performing Merge even when the inputs are arbitrarily interleaved rather than interval-disjoint. Early work permitted only merges of interval-disjoint sets; newer approaches, such as the gap-weighted biased skip lists of Iacono and Özkan, support arbitrary merges with O(log n) amortized cost per operation (Iacono et al., 2010). Each set is stored as a gap-weighted biased skip list, and the merge operation algorithmically extracts “segments”—maximal runs from either set—using finger-based searches and reweightings, then joins them in order. A global potential function based on log‐gap sums guarantees amortized optimality.

Mergeable trees generalize these concepts to dynamic rooted trees (0711.1682). The core merge operation alternately zips two upward paths into a single heap-ordered structure, restructuring Θ(n) arcs in one sweep. The main log² n-time solution wraps a link-cut tree, introduces a “topmost” ancestor primitive, and tracks parent-pointer changes via a log-based potential. Special cases (where arc deletions are forbidden) admit log n per-operation via rank-decomposition and finger search trees.

Biased segment-merge on search trees further provides O(log U) amortized merges, splits, searches, shifts, and singleton insertions, where U is the local universe size (Bille et al., 2019). Lazy propagation of shift-offsets allows efficient translation (Shift) of entire sets, key for compressed-text search and interval translation in dynamic trees.

2. Confluent and Persistent Set Merger Structures

Confluently persistent merger structures support concurrent edit workflows, multi-version conflict detection, and efficient set merging in persistent data models (Liljenzin, 2013). These utilize purely functional binary search trees with unique hash-based priorities (treaps), hash-consing for maximal substructure sharing, and algorithms for non-destructive set merge, intersection, difference, and symmetric difference, all supporting arbitrary overlap. The expected cost for set union or intersection is O(m log(n/m)), where m is the number of modifications and n is the set size; this is achieved by recursive splitting and joining based on priority order. Three-way meld algorithms detect and resolve edit conflicts efficiently by fast pointer comparison of shared subtrees and hashing.

3. Efficient Merging in Succinct and Specialized Structures

Succinct merger data structures focus on compact representation during union or aggregation. For indexed de Bruijn graphs (central in genomics), the BOSS representation allows for merging two graphs with only O(n) bits working space, streaming input arrays sequentially and computing merged output via iterative block partitioning and LCP arrays (Egidi et al., 2020). Wheeler graphs (a broader family encompassing compressed string indexes) admit a space-efficient merger via implicit 2-SAT and iterative partition refinement, subject to Wheeler order compatibility. Variable order de Bruijn graphs are supported natively by maintaining enriched LCP blocks for the merge.

Specialized merger structures also exist in parallel and distributed contexts. FLiMS provides a low-resource, high-throughput, parallel merging primitive for sorted lists in wide/banked memory architectures and SIMD CPUs, consisting of distributed selector stages and pipelined bitonic merge networks (Papaphilippou et al., 2021). Merge Path partitioning yields synchronization-free, cache-efficient parallel merge algorithms for arrays, partitioning the input merge matrix into monotonic paths and dividing the output among processors via diagonal binary search (Green et al., 2014).

4. Algorithmic Frameworks and Merge Algebra

Many merger data structures exploit algebraic frameworks for compositional merging. Exactly mergeable summaries are functions from subsets of data to summary objects, admitting associative and commutative merge operations F such that Σ(A∪B)=F(Σ(A),Σ(B)), with identity element and commutative monoid structure (Batagelj, 2023). Examples include cardinality, extrema, top-k lists (merged by sorted union and truncation), and moment-based summaries (merged by weighted means and sum of squares). Streaming and parallel fold implementations enable efficient summarization over large data sets.

More complex merger algorithms, such as those in regularized arrangements of cellular complexes (LAR), perform spatial mergers of high-dimensional topological structures by assembling (d–1)-skeletons, spatial indexing potential intersections, constructing local facet arrangements, quotienting coincident cells, and extracting d-cells by minimal cycles (Paoluzzi et al., 2017). These pipelines are implemented via sparse matrix operations and suit GPU acceleration.

5. Data Formats, Traversal Schemes, and Application Domains

Merger data structures play crucial roles in application-specific data formats and traversal protocols. The Sussing Merger Tree HDF5 format for dark-matter simulations unifies temporal merger trees and spatial structure trees, encoding parent-child relations, indices, properties, and traversal pointers in hierarchical, array-based layouts (Thomas et al., 2015). Traversal schemes derive from pointer arrays that express main subhalo/progenitor, direct host/descendant, and siblings, supporting efficient lineage extraction and hybrid traversals.

In geometric modeling, merger algorithms underpin Boolean operations, mesh repair, decimation, free-space extraction, and topology-aware filtering (Paoluzzi et al., 2017). In compressed text indexing, mergeable dictionaries with shifts support phrase boundary management, dynamic re-rooting, and spliced tree maintenance (Bille et al., 2019). In distributed aggregation, exactly mergeable summaries enable parallel, error-bounded analytics on large/big data (Batagelj, 2023).

6. Comparative Analysis, Limitations, and Open Questions

Comparative analyses across merger structures highlight trade-offs in operation time bounds, composition complexity, and support for dynamic or overlapping merges. Early schemes limited merge to interval-disjoint inputs; modern approaches (biased skip lists, treaps, LAR matrices) support arbitrary overlaps at optimal cost (Iacono et al., 2010, Liljenzin, 2013, Bille et al., 2019, Paoluzzi et al., 2017). Lower bounds for mergeable trees with cuts or parent operators match Ω(log n) in the cell-probe model (0711.1682). Merge path and FLiMS architectures optimize parallel throughput and resource area in hardware/software, with empirical results demonstrating superior latency, frequency, and scalability (Papaphilippou et al., 2021, Green et al., 2014). In persistent indexing, equality-testing via hash-consed treaps delivers O(1) verification and maximal memory sharing (Liljenzin, 2013).

Open challenges remain in supporting fully dynamic links/cuts/merges, space-efficient partition refinement for Wheeler graphs, and constant-space, error-free merges for extended summary types. Merging of non-compatible Wheeler graphs, cell-complex arrangements in high dimension, and integrating gap-weighted merger structures into compressed search remain areas for further research.