Why Some Heaps Support Constant-Amortized-Time Decrease-Key Operations, and Others Do Not

@article{Iacono2014WhySH,
  title={Why Some Heaps Support Constant-Amortized-Time Decrease-Key Operations, and Others Do Not},
  author={John Iacono and {\"O}zg{\"u}r {\"O}zkan},
  journal={ArXiv},
  year={2014},
  volume={abs/1302.6641}
}
A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend \(\Omega \left( \frac{\log \log n}{\log \log \log n} \right)\) amortized time on the Decrease-Key operation (given O(logn) amortized-time Extract-Min). Intuitively, this bound shows the key to having O(1)-time Decrease-Key is the ability to sort O(logn) items in O(logn) time; Fibonacci heaps [M. .L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through… 
A Tight Lower Bound for Decrease-Key in the Pure Heap Model
TLDR
The result shows that sort heaps as well as pure-heap variants of numerous other heaps have asymptotically optimal decrease-key operations in the pure heap model.
Toward Optimal Self-Adjusting Heaps
TLDR
It is shown how to reduce the amortized cost for meld to be paid by the other operations, on the expense of increasing that of delete-min to O(log n + log log N), where N is the total number of elements in the collection of heaps of the data structure.
A Tight Analysis of Slim Heaps and Smooth Heaps
TLDR
This work obtains amortized bounds on the time per operation of smooth and slim heaps, the first known data structures to match Iacono and Özkan’s lower bounds and to satisfy the constraints of their model.
Hollow Heaps
TLDR
The hollow heap is introduced, a very simple data structure with the same amortized efficiency as the classical Fibonacci heap, using a dag (directed acyclic graph) instead of a tree or set of trees to represent a heap.
D S ] 2 2 O ct 2 01 5 Hollow Heaps ∗
TLDR
The hollow heap is introduced, a very simple data structure with the same amortized efficiency as the classical Fibonacci heap, using a dag (directed acyclic graph) instead of a tree or set of trees to represent a heap.
Smooth heaps and a dual view of self-adjusting data structures
TLDR
The smooth heap is shown to be the heap-counterpart of Greedy, the BST algorithm with the strongest proven and conjectured properties from the literature, conjectured to be instance-optimal, initiating a theory of dynamic optimality for heaps.
Pairing heaps: the forward variant
TLDR
It is shown that inserting an item and deleting the minimum in a forward-variant pairing heap both take amortized time, the first improvement over the O(\sqrt{n})$ bound showed by Fredman et al. three decades ago.
Analysis of Smooth Heaps and Slim Heaps
TLDR
A new, self-contained analysis of smooth heaps and slim heaps in unrestricted operation is given, obtaining amortized bounds that match the best bounds known for self-adjusting heaps.
A Linear Potential Function for Pairing Heaps
We present the first potential function for pairing heaps with linear range. This implies that the runtime of a short sequence of operations is faster than previously known. It is also simpler than
Dynamic algorithms: new worst-case and instance-optimal bounds via new connections
This thesis studies a series of questions about dynamic algorithms which are algorithms for quickly maintaining some information of an input data undergoing a sequence of updates. The first questio
...
...

References

SHOWING 1-10 OF 33 REFERENCES
Pairing heaps: experiments and analysis
TLDR
It is proved that, assuming no decrease_key operations are performed, the most promising algorithm in the simulations is a new variant of the twopass method, called auxiliary Twopass, that achieves the same amortized time bounds as Fibonacci heaps.
Towards a final analysis of pairing heaps
  • Seth Pettie
  • Computer Science
    46th Annual IEEE Symposium on Foundations of Computer Science (FOCS'05)
  • 2005
TLDR
It is proved that pairing heaps support the deletemin operation in optimal logarithmic time and all other operations (insert, meld, and decreasekey) in time O(2/sup 2 /spl radic/(log log n)/).
The Violation Heap: a Relaxed Fibonacci-like Heap
  • Amr Elmasry
  • Computer Science
    Discret. Math. Algorithms Appl.
  • 2010
TLDR
The main idea behind the construction is to propagate rank updates instead of performing cascaded cuts following a decrease-key operation, allowing for a relaxed structure.
Pairing heaps with O(log log n) decrease cost
We give a variation of the pairing heaps for which the time bounds for all the operations match the lower bound proved by Fredman for a family of similar self-adjusting heaps. Namely, our heap
On the efficiency of pairing heaps and related data structures
TLDR
It is demonstrated, contrary to conjecture, that the pairing heap requires more than constant amortized time to perform decrease-key operations.
Improved Upper Bounds for Pairing Heaps
TLDR
It is shown that pairing heaps have a distribution sensitive behavior whereby the cost to perform an extract-min on an element x is O(log min(n, k) where k is the number of heap operations performed since x's insertion.
Self-Adjusting Heaps
TLDR
In this paper, two themes in data structure design are explored: amortized computational complexity and self adjustment.
Pairing Heaps with Costless Meld
TLDR
A variation of pairing heaps that has amortized zero cost per meld and bounds that match the lower bound established by Fredman for a family of such priority queues are given.
Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms
TLDR
The structure, Fibonacci heaps (abbreviated F-heaps), extends the binomial queues proposed by Vuillemin and studied further by Brown to obtain improved running times for several network optimization algorithms.
Rank-Pairing Heaps
We introduce the rank-pairing heap, an implementation of heaps that combines the asymptotic efficiency of Fibonacci heaps with much of the simplicity of pairing heaps. Other heap implementations that
...
...