Results 1  10
of
10
Splay trees, DavenportSchinzel sequences, and the deque conjecture
, 2007
"... We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence S, none of whose subsequences are isomorphic to fixed forbidden subsequence. We direct ..."
Abstract

Cited by 15 (5 self)
 Add to MetaCart
We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence S, none of whose subsequences are isomorphic to fixed forbidden subsequence. We direct this technique towards Tarjan’s deque conjecture and prove that n deque operations require O(nα ∗ (n)) time, where α ∗ (n) is the minimum number of applications of the inverseAckermann function mapping n to a constant. We are optimistic that this approach could be directed towards other open conjectures on splay trees such as the traversal and split conjectures.
Twotier relaxed heaps
 Proceedings of the 17th International Symposium on Algorithms and Computation, Lecture Notes in Computer Science 4288, SpringerVerlag
, 2006
"... Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at mos ..."
Abstract

Cited by 11 (8 self)
 Add to MetaCart
Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at most lg n + 3 lg lg n + O(1) element comparisons for delete, improving the bound of 3lg n + O(1) on the number of element comparisons known for runrelaxed heaps. Here, n denotes the number of elements stored prior to the operation in question, and lg n equals max {1, log 2 n}. 1
A Practical Minimum Spanning Tree Algorithm Using the Cycle Property
 IN 11TH EUROPEAN SYMPOSIUM ON ALGORITHMS (ESA), NUMBER 2832 IN LNCS
, 2003
"... We present a simple new (randomized) algorithm for computing minimum spanning trees that is more than two times faster than the best previously known algorithms (for dense, "difficult" inputs). It is of conceptual interest that the algorithm uses the property that the heaviest edge in a cycle can be ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
We present a simple new (randomized) algorithm for computing minimum spanning trees that is more than two times faster than the best previously known algorithms (for dense, "difficult" inputs). It is of conceptual interest that the algorithm uses the property that the heaviest edge in a cycle can be discarded. Previously this has only been exploited in asymptotically optimal algorithms that are considered impractical. An additional advantage is...
Pairing heaps with O(log log n) decrease cost
 In 20th ACMSIAM Symposium on Discrete Algorithms
, 2009
"... 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 selfadjusting heaps. Namely, our heap structure requires O(1) for insert and findmin, O(log n) for deletemin, and O(log log n) for decreasekey a ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
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 selfadjusting heaps. Namely, our heap structure requires O(1) for insert and findmin, O(log n) for deletemin, and O(log log n) for decreasekey and meld (all the bounds are in the amortized sense except for findmin). 1
Thin Heaps, Thick Heaps
, 2006
"... The Fibonacci heap was devised to provide an especially efficient implementation of Dijkstra’s shortest path algorithm. Although asyptotically efficient, it is not as fast in practice as other heap implementations. Expanding on ideas of Høyer, we describe three heap implementations (two versions of ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
The Fibonacci heap was devised to provide an especially efficient implementation of Dijkstra’s shortest path algorithm. Although asyptotically efficient, it is not as fast in practice as other heap implementations. Expanding on ideas of Høyer, we describe three heap implementations (two versions of thin heaps and one of thick heaps) that have the same amortized efficiency as Fibonacci heaps but need less space and promise better practical performance. As part of our development, we fill in a gap in Høyer’s analysis.
Violation heaps: A better substitute for Fibonacci heaps
, 812
"... 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 2 (0 self)
 Add to MetaCart
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. 1
RankPairing Heaps
"... Abstract. 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 c ..."
Abstract
 Add to MetaCart
Abstract. 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. 1
Strict Fibonacci Heaps
"... Wepresentthefirstpointerbasedheapimplementationwith time bounds matching those of Fibonacci heaps in the worst case. We support makeheap, insert, findmin, meld and decreasekey in worstcase O(1) time, and delete and deletemin in worstcase O(lgn) time, where n is the size of the heap. The data s ..."
Abstract
 Add to MetaCart
Wepresentthefirstpointerbasedheapimplementationwith time bounds matching those of Fibonacci heaps in the worst case. We support makeheap, insert, findmin, meld and decreasekey in worstcase O(1) time, and delete and deletemin in worstcase O(lgn) time, where n is the size of the heap. The data structure uses linear space. A previous, very complicated, solution achieving the same time bounds in the RAM model made essential use of arrays and extensive use of redundant counter schemes to maintain balance. Our solution uses neither. Our key simplification is to discard the structure of the smaller heap when doing a meld. We use the pigeonhole principle in place of the redundant counter mechanism.
Pairing Heaps with Costless Meld
, 903
"... Improving the structure and analysis in [1], we give a variation of the pairing heaps that has amortized zero cost per meld (compared to an O(log log n) in [1]) and the same amortized bounds for all other operations. More precisely, the new pairing heap requires: no cost per meld, O(1) per findmin ..."
Abstract
 Add to MetaCart
Improving the structure and analysis in [1], we give a variation of the pairing heaps that has amortized zero cost per meld (compared to an O(log log n) in [1]) and the same amortized bounds for all other operations. More precisely, the new pairing heap requires: no cost per meld, O(1) per findmin and insert, O(log n) per deletemin, and O(log log n) per decreasekey. These bounds are the best known for any selfadjusting heap, and match the lower bound proven by Fredman for a family of such heaps. Moreover, our structure is even simpler than that in [1]. 1