Two-Way Merge in Sorting & Systems

• Two-way merge is a binary composition process that combines two ordered inputs into a single output while preserving stability and internal order.
• Key techniques such as co-ranking and Merge Path enable parallel processing with balanced load distribution and efficient cache usage under O(m+n) complexity.
• Beyond sorting, two-way merge principles extend to hardware implementations, model checkpoint composition, and database reconciliation, emphasizing both performance and semantic correctness.

Two-way merge denotes the combination of two inputs into one output under an ordering or consistency constraint. In the classical algorithmic sense, it takes two sorted sequences and produces a single sorted sequence, often with a stability requirement that equal keys from one designated input precede equal keys from the other while preserving each input’s internal order (Siebert et al., 2013). In contemporary usage, the same term also appears in high-throughput hardware merging, parallel graph construction, model checkpoint composition, and reconciliation of divergent database histories, where the common structure is a binary composition operator constrained by correctness, order preservation, or semantic consistency (Papaphilippou et al., 2021, Zhang et al., 15 Sep 2025, Bolton et al., 14 Jan 2026, Ranjan et al., 2021).

1. Classical sorted-sequence merge

For two sorted arrays $A$ and $B$ of lengths $m$ and $n$, a two-way merge produces an array $C$ of length $m+n$ in nondecreasing order. A stable merge additionally requires that, for equal keys, all occurrences from $A$ appear before all occurrences from $B$, and that relative order within each array is preserved (Siebert et al., 2013). The standard sequential procedure maintains indices into $A$ and $B$, repeatedly outputs the smaller head element, and on ties chooses consistently from one designated side; with $B$0-first stability, the comparison is $B$1 (Green et al., 2014).

The fundamental complexity remains linear in the input sizes, $B$2 (Papaphilippou et al., 2021). In the conventional out-of-place form, the merge writes into a separate output array $B$3 of size $B$4; the literature cited here notes that in-place stable merges exist but are complex, typically use rotation or block-merge techniques, and have worse constant factors, whereas the out-of-place form is standard and cache-friendly (Green et al., 2014).

In comparison-based analysis, the same procedure is often called tape merge. Its worst-case number of pairwise comparisons is $B$5, because each comparison discards one candidate from further competition until one list is exhausted, after which the remainder of the other list is appended without further comparisons (Li et al., 2016). This is the baseline against which optimality and lower bounds are usually formulated.

2. Co-ranking, partition boundaries, and parallel merge

A central development in parallel two-way merge is co-ranking: for any output prefix length $B$6 with $B$7, there exist unique co-ranks $B$8 and $B$9 such that $m$0 and the output prefix $m$1 is exactly the stable merge of $m$2 and $m$3 (Siebert et al., 2013). With sentinels $m$4 and $m$5, the co-ranks are characterized by

$m$6

with the weak/strict asymmetry encoding stability: equal keys are awarded to $m$7 first across the boundary (Siebert et al., 2013). The feasible interval is

$m$8

Binary search on this interval yields the unique co-rank in $m$9 comparisons, hence $n$0 in the worst case (Siebert et al., 2013). This enables exact partitioning of the output into contiguous blocks. For processor $n$1 among $n$2 processing elements, the boundaries are

$n$3

and the processor merges $n$4 with $n$5 into $n$6 (Siebert et al., 2013). The resulting segments are disjoint on both input and output, no synchronization is required during merging, and the work is perfectly load-balanced in the sense that output blocks differ by at most one element (Siebert et al., 2013).

The same partitioning principle is presented geometrically by Merge Path, which interprets the merge as a monotone path on an $n$7 grid and observes that each cross diagonal $n$8 intersects that path at exactly one point (Green et al., 2014). This yields a visually intuitive derivation of the same co-ranking conditions and supports synchronization-free shared-memory merging with per-thread time approximately $n$9 (Green et al., 2014). A further cache-aware extension, Segmented Parallel Merge, uses segment length $C$0 when the cache size is $C$1 elements and associativity is at least $C$2, so that active inputs and outputs fit within the cache layout assumed in the proof sketch (Green et al., 2014).

A closely related simplification on the EREW PRAM removes the additional merge of distinguished samples used in earlier binary-search partitioning methods. For ordered sequences with $C$3 and $C$4 elements, $C$5, the resulting stable parallel merge runs in $C$6 operations using $C$7 processing elements and requires only a single synchronization step between boundary discovery and local merging (Träff, 2012).

3. Stability, correctness, and optimality in the comparison model

Stability in two-way merge is not a cosmetic refinement; in the cited parallel algorithms it is built directly into the boundary inequalities. The condition $C$8 is weak, while $C$9 is strict, so if $m+n$0, the boundary shifts rightward in $m+n$1 rather than allowing an equal element from $m+n$2 to precede it (Siebert et al., 2013). The same asymmetry appears in sequential merge, where $m+n$3 yields $m+n$4-first stability, and replacing it by $m+n$5 yields the corresponding $m+n$6-first variant (Green et al., 2014).

Optimality results for tape merge are substantially more delicate than the linear-time complexity statement. It was already known that tape merge is optimal in the worst case for equal-size lists and, more generally, when $m+n$7 (Li et al., 2016). The cited extension proves that tape merge remains optimal whenever

$m+n$8

that is, when the larger list is at most $m+n$9 times the smaller (Li et al., 2016). The proof is based on Knuth’s adversary methods together with new inequalities such as

$A$0

and

$A$1

for the restricted adversary lower bound (Li et al., 2016).

The same work also establishes a limitation of that adversary framework: the lower bound cannot be improved to a $A$2 ratio via Knuth’s adversary methods (Li et al., 2016). More precisely, for all $A$3 with $A$4, one has $A$5 (Li et al., 2016). This does not merely constrain proof technique. In the range $A$6, a Modified Binary Merge procedure gives constant improvements over earlier upper bounds, including

$A$7

for $A$8 and $A$9, and

$B$0

for $B$1 (Li et al., 2016). A common misconception is therefore that the head-to-head sequential merge is universally worst-case optimal; the results cited here show optimality only through a bounded size-ratio regime.

4. Hardware realizations and throughput-oriented architectures

In hardware, two-way merge is typically realized as a fixed, data-oblivious compare-exchange network rather than a pointer-driven branchy procedure. FLiMS targets the setting in which two sorted lists reside in banked and/or wide memory and the architecture can deliver up to $B$2 elements per cycle per input list (Papaphilippou et al., 2021). Its core organization has three parts: a selector stage of distributed MAX units, a butterfly compare-and-swap network that sorts the selected block, and a banked output stage emitting exactly $B$3 elements per valid pipeline cycle (Papaphilippou et al., 2021).

For FLiMS, the comparator count is

$B$4

the latency is

$B$5

the initiation interval is $B$6, and the steady-state throughput is $B$7 items per cycle, assuming the input banks can deliver one head per bank per cycle (Papaphilippou et al., 2021). The work complexity remains $B$8, while the cycle count is approximated as

$B$9

The design includes a skewness optimization for duplicate-heavy inputs, a stable variant that appends metadata $A$0 to the compared values, and FLiMSj, which reduces dequeue signaling at the cost of increasing latency to $A$1 (Papaphilippou et al., 2021). On a Xilinx Alveo U280 with 64-bit data, FLiMS is reported as approximately $A$2–$A$3 more hardware-efficient than WMS/EHMS across $A$4, and it often achieves more than $A$5 higher $A$6 (Papaphilippou et al., 2021).

A distinct FPGA-oriented line is List Offset Merge Sorters and Single-Stage 2-way Merge Sorters. LOMS arranges the two input lists into an offset two-dimensional setup array and completes the merge in exactly two pipelinable stages: a full column sort followed by a full row sort (Kent et al., 11 Jul 2025). S2MS performs the entire merge in a single combinational stage, with stage depth

$A$7

whereas for LOMS two-way merge

$A$8

Both accept arbitrary list sizes, including unequal and non-power-of-two cases, unlike Batcher’s Bitonic and Odd-Even merge sorters, which are easiest to design when both input lists are equal and powers of two (Kent et al., 11 Jul 2025). A cited representative result is a List Offset 2-way sorter that merges two lists of $A$9 values into a sorted $B$0-value output in $B$1, with a speedup of $B$2 versus a comparable Batcher device (Kent et al., 11 Jul 2025).

These hardware results highlight another recurring distinction: correctness of order does not imply stability by default. FLiMS explicitly states that it is not inherently stable because bitonic networks are not stable, and its stable mode requires extended comparison keys (Papaphilippou et al., 2021). LOMS can inherit stability from stable S2MS units in the column stage, but stable primitives must be used throughout if global stability is required (Kent et al., 11 Jul 2025).

5. Generalizations beyond sorted-list merging

In model merging for LLMs, a two-way merge combines two fine-tuned checkpoints $B$3 and $B$4, derived from a common pretrained base, into merged parameters

$B$5

where $B$6 is a binary merge operator and $B$7 is a mixing coefficient (Bolton et al., 14 Jan 2026). The cited framework considers Linear, SLERP, and TIES operators, with $B$8 in the main experiments, and replaces expensive merge-and-evaluate search by similarity-based operator prediction from functional and structural signals computed on a small unlabeled probe set (Bolton et al., 14 Jan 2026). In 240 training merges, the best operator is Linear in $B$9 cases, Slerp in $B$00, and Ties in $B$01, which directly supports the claim that no single fixed operator dominates across regimes (Bolton et al., 14 Jan 2026).

In large-scale $B$02-NN graph construction, Two-way Merge denotes the merger of two subgraphs built on disjoint subsets. The algorithm fixes a support list $B$03 from sampled neighbors and reverse neighbors in the local subgraphs, maintains a cross-subset neighbor list $B$04, and performs Local-Join only between fixed intra-subset samples and new cross-subset candidates (Zhang et al., 15 Sep 2025). For two subgraphs, the time complexity is

$B$05

and hierarchical merging of $B$06 subgraphs costs

$B$07

(Zhang et al., 15 Sep 2025). In the distributed multi-node procedure, a billion-scale $B$08-NN graph can be built in approximately $B$09h when only three nodes are employed, and for SIFT1B the paper reports approximately $B$10h on $B$11 nodes with Recall@10 $B$12 (Zhang et al., 15 Sep 2025).

In collaborative databases, two-way merge is semantic rather than order-statistical. MindPalace defines it as reconciling two divergent branches by interleaving two sequences of logical modifications while preserving each branch’s internal order (Ranjan et al., 2021). If $B$13 and $B$14, the histories are auto-mergeable if and only if every valid interleaving yields the same final database state (Ranjan et al., 2021). Conflict detection is then based on pairwise non-commutativity of cross-branch operations on appropriate intermediate states, with polynomial $B$15 complexity rather than exponential enumeration over all interleavings (Ranjan et al., 2021). This suggests a broader interpretation of two-way merge as binary composition under order constraints, even when the merged object is not a sorted sequence.

6. Recurrent trade-offs and misconceptions

Across these literatures, two-way merge repeatedly exposes the same design tensions: stability versus raw throughput, perfect balance versus partitioning overhead, and semantic fidelity versus low-level regularity. In classical sorted merging, the weak/strict inequality pattern at partition boundaries is sufficient to encode stable tie-breaking without extra space or time cost (Siebert et al., 2013). In hardware, by contrast, stability is often not inherent and may require explicit metadata or stable compare-exchange primitives (Papaphilippou et al., 2021, Kent et al., 11 Jul 2025). In semantic systems such as collaborative databases, the analogue of stability is not tie order but invariance of the final state across all valid interleavings (Ranjan et al., 2021).

A second misconception is that two-way merge is inherently sequential. Co-ranking, Merge Path, and related EREW PRAM formulations show that the merge can be partitioned exactly by output rank, with disjoint output slices and no synchronization during the local merge phase (Siebert et al., 2013, Green et al., 2014, Träff, 2012). Another is that two-way merge is always trivial once both inputs are “already ordered.” The model-merging results show that operator choice is regime-dependent even when both models share a common base (Bolton et al., 14 Jan 2026), and the graph-merging results show that merge quality depends positively on subgraph quality and on the sampling budget $B$16 (Zhang et al., 15 Sep 2025).

A plausible implication is that “two-way merge” is best understood not as a single algorithm but as a family of binary composition procedures. In the sorted-list setting, the family ranges from tape merge through co-ranking-based parallel merge to banked and SIMD hardware realizations; in broader systems, it includes checkpoint composition, graph consolidation, and reconciliation of divergent histories. What remains invariant is the binary structure of the operation and the need to preserve a domain-specific notion of order, locality, or semantic equivalence.