Implementation Of Priority Queue Research Articles

Optimal purely functional priority queues

AbstractBrodal recently introduced the first implementation of imperative priority queues to supportfindMin, insertandmeldinO(1) worst-case time, anddeleteMininO(logn) worst-case time. These bounds are asymptotically optimal among all comparison-based 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 inO(logn) time. Specifically, we derive our implementation from binomial queues in three steps: first, we reduce the running time ofinserttoO(1) by eliminating the possibility of cascading links; second, we reduce the running time offindMintoO(1) by adding a global root to hold the minimum element; and finally, we reduce the running time ofmeldtoO(1) by allowing priority queues to contain other priority queues. Each of these steps is expressed using ML-style functors. The last transformation, known as data-structural bootstrapping, is an interesting application of higher-order functors and recursive structures.

Optimal Purely Functional Priority Queues

Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worst-case time, and deleteMin in O(log n) worst-case time. These bounds are asymptotically optimal among all comparison-based priority queues. In this paper, we adapt<br />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<br />priority queues. Each of these steps is expressed using ML-style functors. The last transformation, known as data-structural bootstrapping, is an interesting<br />application of higher-order functors and recursive structures.

A VLSI priority packet queue with inheritance and overwrite

Reliable priority-based flow-control is essential for real-time applications involving hard-deadlines. However, the use of first-in-first-out (FIFO) queues in such systems introduces priority inversion resulting in unbounded transmission delays. For this reason, a priority transmission queue is critical for multimedia and mission-critical systems. Yet very few priority queue implementations exist. This paper presents the design of a novel VLSI priority packet queue (PPQ), implemented in 1.2 /spl mu/m CMOS technology. It achieves fast operation by manipulating its contents in terms of packet segments, rather than individual words. Similar to paged memory, this new segmented architecture greatly reduces implementation cost by reusing segments and avoiding storage area fragmentation. By distributing the computationally intensive priority comparison operation over the access time for an entire segment, the PPQ achieves 96% of the speed of a high-speed packet FIFO. The PPQ can either perform priority inheritance or overwrite lower priority packets to minimize the impact of queue overflow. In addition, it is suitable as a general computer network interface buffer, since it robustly handles asynchronous read and write clocks of greatly disparate frequencies. Our initial implementation achieves well over twice the speed of a nonpipelined approach with minimal additional overhead. Furthermore, scaling this design to larger capacities and more priority levels results in an even greater improvement in speed over conventional approaches.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Fast Meldable Priority Queues

We present priority queues that support the operations MakeQueue,&lt;br /&gt;FindMin, Insert and Meld in worst case time O(1) and Delete and&lt;br /&gt;DeleteMin in worst case time O(log n). They can be implemented on the&lt;br /&gt;pointer machine and require linear space. The time bounds are optimal for&lt;br /&gt;all implementations where Meld takes worst case time o(n).&lt;br /&gt;To our knowledge this is the first priority queue implementation that&lt;br /&gt;supports Meld in worst case constant time and DeleteMin in logarithmic&lt;br /&gt;time.

An application of program unification to priority queue vectorization

In this experimental study, we apply the technique of program unification to priority queues. We examine the performance of a variety of unified priority queue implementations on a Cray Y-MP. The scope of the study is restricted to determining if different implementations of priority queues exhibit markedly different performance characteristics under program unification. We found this to be true. In a larger view, this result has interesting consequences in the application of program unification to discrete event simulations on vector or SIMD machines. We find the heap to be a promising data structure in the program unification paradigm.

An optimal parallel algorithm to construct a deap

Recently, Carlsson [3] proposed a variation of the heap data structure as an efficient implementation of a double-ended priority queue. This new data structure is referred to as the deap. We show that constructing a deap with special properties can be done very easily, both sequentially and in parallel, by reducing the problem to selection and heap construction. Our parallel algorithm can be implemented to run in O(log n log ∗ n) time using an optimal number of processors in the EREW-PRAM model or in O(log n) time using an optimal number of processors in the CRCW model.

A path integral approach to data structure evolution

A probabilistic analysis is presented of certain pointer-based implementations of dictionaries, linear lists, and priority queues; in particular, simple list and d-heap implementations. Under the assumption of equiprobability of histories, i.e., of paths through the internal state space of the implementation, it is shown that the integrated space and time costs of a sequence of n supported operations converge as n → ∞ to Gaussian random variables. For list implementations the mean integrated spatial costs grow asymptotically as n 2, and the standard deviations of the costs as n 3 2 . For d-heap implementations of priority queues the mean integrated space cost grows only as n 2√log n, i.e., more slowly than the worst-case integrated cost. The standard deviation grows as n 3 2 . These asymptotic growth rates reflect the convergence as n → ∞ of the normalized structure sizes to datatype-dependent deterministic functions of time, as earlier discovered by Louchard. This phenomenon is clarified with the aid of path integrals. Path integral techniques, drawn from physics, greatly facilitate the computation of the cost asymptotics. This is their first application to the analysis of dynamic data structures.

Lazy queue

A new priority queue implementation, the Lazy Queue, is presented in this paper. It is tailored to handle the pending event set encountered in discrete event simulation. The Lazy Queue is a multi-list variety where the sorting process is delayed until a point near the time where the elements are to be dequeued. The queue access time has been measured and compared with the access times of an implicit heap and a calendar queue. The experimental results indicate that the Lazy Queue is superior to these priority queue implementations. >

Analysis of dynamic algorithms in Knuth's model

This paper analyzes the average behaviour of algorithms that operate on dynamically varying data structures subject to insertions I, deletions D, positive (resp. negative) queries Q + (resp. Q -) under the following assumptions: if the size of the data structure is k (k ϵ N) , then the number of possibilities for the operations D and Q + is a linear function of k, whereas the number of possibilities for the ith insertion or negative query is equal to i. This statistical model was introduced by Françon [6,7] and Knuth [12] and differs from the model used in previous analyses [2–7]. Integrated costs for these dynamic structures are defined as averages of costs taken over the set of all their possible histories (i.e. evolutions considered up to order isomorphism) of length n. We show that the costs can be calculated for the data structures serving as implementations of linear lists, priority queues and dictionaries. The problem of finding the limiting distributions is also considered and the linear list case is treated in detail. The method uses continued fractions and orthogonal polynomials but in a paper in preparation, we show that the same results can be recovered with the help of a probabilistic model.

Concurrent operations on priority queues

Among the fastest priority queue implementations, skew heaps have properties that make them particularly suited to concurrent manipulation of shared queues. A concurrent version of the top down implementation of skew heaps can be produced from previously published sequential versions using almost mechanical transformations. This implementation requires O (log n) time to enqueue or dequeue an item, but it allows new operations to begin after only O(1) time on a MIMD machine. Thus, there is potential for significant concurrency when multiple processes share a queue. Applications to problems in graph theory and simulation are discussed in this article.

Calendar queues: a fast 0(1) priority queue implementation for the simulation event set problem

A new priority queue implementation for the future event set problem is described in this article. The new implementation is shown experimentally to be O(1) in queue size for the priority increment distributions recently considered by Jones in his review article. It displays hold times three times shorter than splay trees for a queue size of 10,000 events. The new implementation, called a calendar queue, is a very simple structure of the multiple list variety using a novel solution to the overflow problem.

The deap—a double-ended heap to implement double-ended priority queues

This paper presents a symmetrical implicit double-ended priority queue implementation, which can be built in linear time. The smallest and the largest element can be found in constant time, and deleted in logarithmic time. This structure is an improvement of the MinMaxHeap presented by Atkinson et al. (1986).

A Note on Bottom-Up Skew Heaps

In testing Sleator and Tarjan’s skew heap implementations of priority queues, a problem with the bottom-up variant was found. The original definition of skew heaps includes the assumption that the keys of items in the heap are disjoint. When this is not true, the delete min operation on bottom-up skew heaps will occasionally discard items from the heap. Modified versions of the delete min algorithm are presented which do not require this assumption.

Min-max heaps and generalized priority queues

A simple implementation of double-ended priority queues is presented. The proposed structure, called a min-max heap, can be built in linear time; in contrast to conventional heaps, it allows both FindMin and FindMax to be performed in constant time; Insert, DeleteMin, and DeleteMax operations can be performed in logarithmic time. Min-max heaps can be generalized to support other similar order-statistics operations efficiently (e.g., constant time FindMedian and logarithmic time DeleteMedian); furthermore, the notion of min-max ordering can be extended to other heap-ordered structures, such as leftist trees.

The amortized complexity of Henriksen's algorithm

Henriksen's algorithm is a priority queue implementation that has been proposed for the event list found in discrete event simulations. It offers several practical advantages over heaps and tree structures.

Sequence of operations analysis for dynamic data structures

This paper introduces a rather general technique for computing the average-case performance of dynamic data structures, subjected to arbitrary sequences of insert, delete, and search operations. The method allows us effectively to evaluate the integrated cost of various interesting data structure implementations, for stacks, dictionaries, symbol tables, priority queues, and linear lists; it can thus be used as a basis for measuring the efficiency of each proposed implementation. For each data type, a specific continued fraction and a family of orthogonal polynomials are associated with sequences of operations: Tchebycheff for stacks, Laguerre for dictionaries, Charlier for symbol tables, Hermite for priority queues, and Meixner for linear lists. Our main result is an explicit expression, for each of the above data types, of the generating function for integrated costs, as a linear integral transform of the generating functions for individual operation costs. We use the result to compute explicitly integrated costs of various implementations of dictionaries and priority queues.

Design and implementation of an efficient priority queue

We present a data structure, based upon a hierarchically decomposed tree, which enables us to manipulate on-line a priority queue whose priorities are selected from the interval 1,⋯,n with a worst case processing time of $$\mathcal{O}$$ (log logn) per instruction. The structure can be used to obtain a mergeable heap whose time requirements are about as good. Full details are explained based upon an implementation of the structure in a PASCAL program contained in the paper.