Results 1 
9 of
9
Optimal Purely Functional Priority Queues
 JOURNAL OF FUNCTIONAL PROGRAMMING
, 1996
"... Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worstcase time, and deleteMin in O(log n) worstcase time. These bounds are asymptotically optimal among all comparisonbased priority queues. In this paper, we adapt B ..."
Abstract

Cited by 18 (1 self)
 Add to MetaCart
Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worstcase time, and deleteMin in O(log n) worstcase time. These bounds are asymptotically optimal among all comparisonbased priority queues. In this paper, we adapt Brodal's data structure to a purely functional setting. In doing so, we both simplify the data structure and clarify its relationship to the binomial queues of Vuillemin, which support all four operations in O(log n) time. Specifically, we derive our implementation from binomial queues in three steps: first, we reduce the running time of insert to O(1) by eliminating the possibility of cascading links; second, we reduce the running time of findMin to O(1) by adding a global root to hold the minimum element; and finally, we reduce the running time of meld to O(1) by allowing priority queues to contain other priority queues. Each of these steps is expressed using MLstyle functors. The last transformation, known as datastructural bootstrapping, is an interesting application of higherorder functors and recursive structures.
Two new methods for transforming priority queues into doubleended priority queues
 CPH STL Report
, 2006
"... Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can pr ..."
Abstract

Cited by 5 (5 self)
 Add to MetaCart
Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can produce a doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; and the worstcase cost of O(lg n) including at most lg n + O(1) element comparisons for delete, but the data structure cannot support meld efficiently. Using a meldable priority queue that supports decrease efficiently, the second transformation can produce a meldable doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; the worstcase cost of O(lg n) including at most lg n + O(lg lg n) element comparisons for delete; and the worstcase cost of O(min {lg m, lg n}) for meld. Here, m and n denote the number of elements stored in the data structures prior to the operation in question, and lg n is a shorthand for log 2 (max {2, n}). 1.
A Note on Worst Case Efficient Meldable Priority Queues
, 1996
"... We give a simple implementation of meldable priority queues, achieving Insert , Find min, and Meld in O(1) worst case time, and Delete min and Delete in O(log n) worst case time. 1 Introduction The implementation of priority queues is a classic problem in computer science. The fundamental operatio ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We give a simple implementation of meldable priority queues, achieving Insert , Find min, and Meld in O(1) worst case time, and Delete min and Delete in O(log n) worst case time. 1 Introduction The implementation of priority queues is a classic problem in computer science. The fundamental operations are Insert and Delete min, but various extra operations, such as Find min, Meld, Delete, and Decrease key , have been considered. Fibonacci heaps [6] support all of these, in O(log n) time for the Delete min and Delete operations, and O(1) for the rest. These bounds are, however, only amortized. Some earlier proposals [4, 5, 8] achieve such bounds in the worst case sense for various subsets of the operations supported by Fibonacci heaps. None of these subsets includes the meld operation. This has been remedied recently by Brodal, who has given worst case solutions, first [2] for the set Insert, Delete min, Find min, Meld, and Delete, and later [3] for the full set of Fibonacci heap opera...
A Generalization of Binomial Queues
 Information Processing Letters
, 1996
"... We give a generalization of binomial queues involving an arbitrary sequence (mk )k=0;1;2;::: of integers greater than one. Different sequences lead to different worst case bounds for the priority queue operations, allowing the user to adapt the data structure to the needs of a specific application. ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We give a generalization of binomial queues involving an arbitrary sequence (mk )k=0;1;2;::: of integers greater than one. Different sequences lead to different worst case bounds for the priority queue operations, allowing the user to adapt the data structure to the needs of a specific application. Examples include the first priority queue to combine a sublogarithmic worst case bound for Meld with a sublinear worst case bound for Delete min. Keywords: Data structures; Meldable priority queues. 1 Introduction The binomial queue, introduced in 1978 by Vuillemin [14], is a data structure for meldable priority queues. In meldable priority queues, the basic operations are insertion of a new item into a queue, deletion of the item having minimum key in a queue, and melding of two queues into a single queue. The binomial queue is one of many data structures which support these operations at a worst case cost of O(logn) for a queue of n items. Theoretical [2] and empirical [9] evidence i...
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.
Mergeable DoubleEnded Priority Queues
, 1999
"... We show that the leftist tree data structure may be adapted to obtain data structures that permit the doubleended priority queue operations Insert, DeleteMin, DeleteMax, and Merge to be done in O(logn) time where n is the size of the resulting queue. The operations FindMin and FindMax can be don ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We show that the leftist tree data structure may be adapted to obtain data structures that permit the doubleended priority queue operations Insert, DeleteMin, DeleteMax, and Merge to be done in O(logn) time where n is the size of the resulting queue. The operations FindMin and FindMax can be done in O(1) time. Experimental results are also presented.
Correspondence Based Data Structures for Double Ended Priority Queues
"... this paper is to demonstrate the generality of two techniques used in [6] to develop an MDEPQ representation from an MPQ representation  height biased leftist trees. These methods  total correspondence and leaf correspondence  may be used to arrive at efficient DEPQ and MDEPQ data structures from ..."
Abstract
 Add to MetaCart
this paper is to demonstrate the generality of two techniques used in [6] to develop an MDEPQ representation from an MPQ representation  height biased leftist trees. These methods  total correspondence and leaf correspondence  may be used to arrive at efficient DEPQ and MDEPQ data structures from PQ and MPQ data structures such as the pairing heap [8; 18], Binomial and Fibonacci heaps [9], and Brodal's FMPQ [2] which also provide efficient support for the operation: Delete(Q,p): delete and return the element located at p We begin, in Section 2, by reviewing a rather straightforward way, dual priority queues, to obtain a (M)DEPQ structure from a (M)PQ structure. This method [2; 6] simply puts each element into both a minPQ and a maxPQ. In Section 3, we describe the total correspondence method and in Section 4, we describe leaf correspondence. Both sections provide examples of PQs and MPQs and the resulting DEPQs and MDEPQs. Section 5 gives complexity results. In Section 6, we provide the result of experiments that compare the performance of the MDEPQs based on height biased leftist tree [7], pairing heaps [8; 18], and FMPQs [2]. For reference purpose, we also provide run times for the splay tree data structure [16]. Although splay trees were not specifically designed to represent DEPQs, it is easy min Heap max Heap Fig. 1. Dual heap structure to use them for this purpose. Note that splay trees do not provide efficient support for the Meld operation
Reflected MinMax Heaps
 Information Processing Letters 86
, 2003
"... In this paper we present a simple and e#cient implementation of a minmax priority queue, reflected minmax priority queues. The main merits of our construction are threefold. First, the space utilization of the reflected minmax heaps is much better than the naive solution of putting two heaps b ..."
Abstract
 Add to MetaCart
In this paper we present a simple and e#cient implementation of a minmax priority queue, reflected minmax priority queues. The main merits of our construction are threefold. First, the space utilization of the reflected minmax heaps is much better than the naive solution of putting two heaps backtoback. Second, the methods applied in this structure can be easily used to transform ordinary priority queues into minmax priority queues. Third, when considering only the setting of minmax priority queues, we support merging in constant worstcase time which is a clear improvement over the best worstcase bounds achieved by Hyer.
A Survey on Priority Queues
"... Abstract. Back in 1964 Williams introduced the binary heap as a basic priority queue data structure supporting the operations Insert and ExtractMin in logarithmic time. Since then numerous papers have been published on priority queues. This paper tries to list some of the directions research on prio ..."
Abstract
 Add to MetaCart
Abstract. Back in 1964 Williams introduced the binary heap as a basic priority queue data structure supporting the operations Insert and ExtractMin in logarithmic time. Since then numerous papers have been published on priority queues. This paper tries to list some of the directions research on priority queues has taken the last 50 years. 1