Skew Heaps Research Articles

Efficiency of Self-Adjusting Heaps

Since the invention of the pairing heap by Fredman, Sedgewick, Sleator, and Tarjan [8], it has been an open question whether this or any other simple “self-adjusting” heap supports decrease-key operations in \(\mathrm{O}(\log\log n)\) time, where \(n\) is the number of heap items. Using powerful new techniques, we answer this question in the affirmative. We prove that both slim and smooth heaps, recently introduced self-adjusting heaps, support heap operations in the following amortized time bounds: \(\mathrm{O}(\log n)\) for delete-min and delete, \(\mathrm{O}(\log\log n)\) for decrease-key, and \(\mathrm{O}(1)\) for all other heap operations, including insert and meld, where \(n\) is the number of heap items that are eventually deleted: Items inserted but never deleted do not count in the bounds. We also analyze the multipass pairing heap, a variant of pairing heaps. For this heap implementation, we obtain the same bounds except for decrease-key, for which our bound is \(\mathrm{O}(\log\log n\cdot\log\log\log n)\) , where again items that are never deleted do not count in \(n\) . Our bounds significantly improve the best previously known bounds for all three data structures. For slim and smooth heaps our bounds are tight, since they match lower bounds of Iacono and Özkan [13].

Toward Optimal Self-Adjusting Heaps

We give a variant of the pairing heaps that achieves the following amortized costs: O (1) per find-min and insert , O (log log n ) per decrease-key and meld , O (log n ) per delete-min ; where n is the number of elements in the resulting heap on which the operation is performed. These bounds are the best known for any self-adjusting heap and match two lower bounds, one established by Fredman and the other by Iacono and Özkan, for a family of self-adjusting heaps that generalizes the pairing heaps but do not include our variant. We further show 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 (not just the heap under consideration by the operation).

Parameterized self-adjusting heaps

We give a parameterized form for the standard implementation of the pairing heaps, skew heaps and skew-pairing heaps. When the node with the minimum value is to be deleted from the heap ( deletemin operation), the procedures used to combine the resulting sub-trees into one tree depend on the value of a parameter k. When the value of k is equal to 2, the implementations are equivalent to the standard implementations. Using more complicated arguments, we show that for some predefined ranges of k this general form achieves the same bounds as the standard implementations. Finally, experimental results are conducted showing that for the pairing heaps, by tuning the value of k, the cost of the deletemin operation is reduced.

A comparative study of parallel and sequential priority queue algorithms

Priority queues are used in many applications including real-time systems, operating systems, and simulations. Their implementation may have a profound effect on the performance of such applications. In this article, we study the performance of well-known sequential priority queue implementations and the recently proposed parallel access priority queues. To accurately assess the performance of a priority queue, the performance measurement methodology must be appropriate. We use the Classic Hold, the Markov Model, and an Up/Down access pattern to measure performance and look at both the average access time and the worst-case time that are of vital interest to real-tiem applicatons. Our results suggest that the best choice for priority queue algorithms depends heavily on the application. For queue sizes smaller than 1,000 elements, the Splay Tree, the Skew Heap, and Henriksen's algorithm show good average access times. For large queue sized of 5,000 elements or more, the Calendar Queue and the Lazy Queue offer good average access times but have very long worst-case access times. The Skew Heap and the splay Tree exhibit the best worst-case access times. Among the parallel access priority queues tested, the Parallel Access Skew Heap provides the best performance on small shares memory multiprocessors.

Three priority queue applications revisited

Results indicate that the two recently introduced self-adjusting heaps are the most competitive choices for the applications considered. Further, the results indicate that only some heap structures support lazymerge/lazydelete operations well, partially confirming that algorithms based on top-down skew heap compare more favorably than those based on binomial queues, that there are strong grounds for believing the conjectured amortized time bounds for pairing heap operations, and that pairing heaps are a competitive alternative to Fibonacci heaps.

Self-Adjusting Heaps

In this paper we explore two themes in data structure design: amortized computational complexity and self adjustment. We are motivated by the following observations. In most applications of data structures, we wish to perform not just a single operation but a sequence of operations, possibly having correlated behavior. By averaging the running time per operation over a worst-case sequence of operations, we can sometimes obtain an overall time bound much smaller than the worst-case time per operation multiplied by the number of operations. We call this kind of averaging amortization.Standard kinds of data structures, such as the many varieties of balanced trees, are specifically designed so that the worst-case time per operation is small. Such efficiency is achieved by imposing an explicit structural constraint that must be maintained during updates, at a cost of both running time and storage space. However, if amortized running time is the complexity measure of interest, we can guarantee efficiency withou...