Why some heaps support constant-amortized-time decrease-key operations, and others do not

TL;DR

This paper establishes a lower bound on the decrease-key operation in pointer-based heaps, introduces a new heap structure called the sort heap with similar performance, and discusses the fundamental limits of such data structures.

Contribution

It presents a new lower bound for decrease-key in pointer heaps and introduces the sort heap, a simplified structure matching this bound.

Findings

Lower bound of Omega(log log n / log log log n) for decrease-key in pointer heaps

Introduction of the sort heap with O(log log n) amortized decrease-key

Demonstration of the gap between self-adjusting heaps and lower bounds

Abstract

A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend Omega(log log n / log log log n) amortized time on the decrease-key operation (given O(log n) amortized-time extract-min). Intuitively, this bound shows the key to having O(1)-time decrease-key is the ability to sort O(log n) items in O(log n) time; Fibonacci heaps [M.L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through the use of bucket sort. Our lower bound also holds no matter how much data is augmented; this is in contrast to the lower bound of Fredman [J. ACM 46(4):473-501 (1999)] who showed a tradeoff between the number of augmented bits and the amortized cost of decrease-key. A new heap data structure, the sort heap, is presented. This heap is a simplification of the heap of Elmasry [SODA 2009: 471-476] and shares with it a O(log log n) amortized-time decrease-key, but with a straightforward implementation such that our lower bound holds. Thus a natural model is presented for a pointer-based heap such that the amortized runtime of a self-adjusting structure and amortized lower asymptotic bounds for decrease-key differ by but a O(log log log n) factor.