Results 1 
9 of
9
RankPairing Heaps
"... We introduce the rankpairing heap, a heap (priority queue) implementation that combines the asymptotic efficiency of Fibonacci heaps with much of the simplicity of pairing heaps. Unlike all other heap implementations that match the bounds of Fibonacci heaps, our structure needs only one cut and n ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
(Show Context)
We introduce the rankpairing heap, a heap (priority queue) implementation that combines the asymptotic efficiency of Fibonacci heaps with much of the simplicity of pairing heaps. Unlike all other heap implementations that match the bounds of Fibonacci heaps, our structure needs only one cut and no other structural changes per key decrease; the trees representing the heap can evolve to have arbitrary structure. Our initial experiments indicate that rankpairing heaps perform almost as well as pairing heaps on typical input sequences and better on worstcase sequences.
Violation heaps: A better substitute for Fibonacci heaps
, 2008
"... We give a priority queue that achieves the same amortized bounds as Fibonacci heaps. Namely, findmin requires O(1) worstcase time, insert, meld and decreasekey require O(1) amortized time, and deletemin requires O(log n) amortized time. Our structure is simple and promises a more efficient pract ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
We give a priority queue that achieves the same amortized bounds as Fibonacci heaps. Namely, findmin requires O(1) worstcase time, insert, meld and decreasekey require O(1) amortized time, and deletemin requires O(log n) amortized time. Our structure is simple and promises a more efficient practical behavior compared to any other known Fibonaccilike heap.
Fibonacci heaps revisited
 CoRR
"... The Fibonacci heap is a classic data structure that supports deletions in logarithmic amortized time and all other heap operations in O(1) amortized time. We explore the design space of this data structure. We propose a version with the following improvements over the original: (i) Each heap is repr ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
The Fibonacci heap is a classic data structure that supports deletions in logarithmic amortized time and all other heap operations in O(1) amortized time. We explore the design space of this data structure. We propose a version with the following improvements over the original: (i) Each heap is represented by a single heapordered tree, instead of a set of trees. (ii) Each decreasekey operation does only one cut and a cascade of rank changes, instead of doing a cascade of cuts. (iii) The outcomes of all comparisons done by the algorithm are explicitly represented in the data structure, so none are wasted. We also give an example to show that without cascading cuts or rank changes, both the original data structure and the new version fail to have the desired efficiency, solving an open problem of Fredman. Finally, we illustrate the richness of the design space by proposing several alternative ways to do cascading rank changes, including a randomized strategy related to one previously proposed by Karger. We leave the analysis of these alternatives as intriguing open problems.
A back–to–basics empirical study of priority queues
, 2013
"... The theory community has proposed several new heap variants in the recent past which have remained largely untested experimentally. We take the field back to the drawing board, with straightforward implementations of both classic and novel structures using only standard, wellknown optimizations. We ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
The theory community has proposed several new heap variants in the recent past which have remained largely untested experimentally. We take the field back to the drawing board, with straightforward implementations of both classic and novel structures using only standard, wellknown optimizations. We study the behavior of each structure on a variety of inputs, including artificial workloads, workloads generated by running algorithms on real map data, and workloads from a discrete event simulator used in recent systems networking research. We provide observations about which characteristics are most correlated to performance. For example, we find that the L1 cache miss rate appears to be strongly correlated with wallclock time. We also provide observations about how the input sequence affects the relative performance of the different heap variants. For example, we show (both theoretically and in practice) that certain random insertiondeletion sequences are degenerate and can lead to misleading results. Overall, our findings suggest that while the conventional wisdom holds in some cases, it is sorely mistaken in others. 1
Hollow Heaps
"... We introduce the hollow heap, a very simple data structure with the same amortized efficiency as the classical Fibonacci heap. All heap operations except delete and deletemin take O(1) time, worst case as well as amortized; delete and deletemin take O(log n) amortized time. Hollow heaps are by far ..."
Abstract
 Add to MetaCart
We introduce the hollow heap, a very simple data structure with the same amortized efficiency as the classical Fibonacci heap. All heap operations except delete and deletemin take O(1) time, worst case as well as amortized; delete and deletemin take O(log n) amortized time. Hollow heaps are by far the simplest structure to achieve this. Hollow heaps combine two novel ideas: the use of lazy deletion and reinsertion to do decreasekey operations, and the use of a dag (directed acyclic graph) instead of a tree or set of trees to represent a heap. Lazy deletion produces hollow nodes (nodes without items), giving the data structure its name.
Heaps Simplified
, 2009
"... The heap is a basic data structure used in a wide variety of applications, including shortest path and minimum spanning tree algorithms. In this paper we explore the design space of comparisonbased, amortizedefficient heap implementations. From a consideration of dynamic singleelimination tourn ..."
Abstract
 Add to MetaCart
(Show Context)
The heap is a basic data structure used in a wide variety of applications, including shortest path and minimum spanning tree algorithms. In this paper we explore the design space of comparisonbased, amortizedefficient heap implementations. From a consideration of dynamic singleelimination tournaments, we obtain the binomial queue, a classical heap implementation, in a simple and natural way. We give four equivalent ways of representing heaps arising from tournaments, and we obtain two new variants of binomial queues, a onetree version and a onepass version. We extend the onepass version to support key decrease operations, obtaining the rankpairing heap, or rpheap. Rankpairing heaps combine the performance guarantees of Fibonacci heaps with simplicity approaching that of pairing heaps. Like pairing heaps, rankpairing heaps consist of trees of arbitrary structure, but these trees are combined by rank, not by list position, and rank changes, but not structural changes, cascade during key decrease operations.
A note on meldable heaps relying on datastructural bootstrapping
, 2009
"... We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structure is asymp ..."
Abstract
 Add to MetaCart
(Show Context)
We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structure is asymptotically optimal and nearly constantfactor optimal with respect to the comparison complexity of all the meldableheap operations. Furthermore, the data structure is also simple and elegant.