Pure Pairing Heaps

2026-07-25

AI Summary

This work addresses the longstanding trade-off between efficiency and structural simplicity in pairing heaps during the delete-min operation by introducing the “pure pairing heap.” This variant simplifies the data structure by omitting the consolidation phase of delete-min and employs a novel grouping strategy to enable refined amortized analysis. The resulting design achieves, for the first time in a simplified model, near-optimal time bounds matching theoretical lower limits: O(log n) for delete-min, O(log log n · log log log n) for decrease-key, and O(1) amortized for both insert and meld operations. The analytical framework further extends to lazy pairing heaps, offering both theoretical insight and practical relevance.

Abstract

The pairing heap is a "self-adjusting" implementation of a heap (priority queue) that is widely used in practice because it is simple and efficient. We introduce and analyze a simplified version of the pairing heap that we call the pure pairing heap. Our innovation is to eliminate the assembly pass during delete-min operations. We obtain the following amortized time bounds for operations on pure pairing heaps: $O(\log n)$ time per delete-min, $O(\log\log n \cdot \log\log\log n)$ time per decrease-key operation, and $O(1)$ time for each insert or meld. These bounds match those recently obtained for a more complicated version of pairing heaps, the multipass pairing heap}. These bounds also match the known lower bounds for self-adjusting heaps, except for the decrease-key bound, which is within a factor of $\log\log\log n$ of the lower bound. The main novelty in our analysis is to partition heap items into groups and to analyze each group separately. Our analysis extends to give the same bounds for lazy pairing heaps, a multitree version of pairing heaps.

Problem

• pairing heap
• delete-min
• self-adjusting heap
• amortized time bounds
• decrease-key

Innovation

• pure pairing heap
• amortized analysis
• self-adjusting heap
• decrease-key complexity
• assembly pass elimination