Results 11  20
of
29
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.
Relaxed weak queues: an alternative to runrelaxed heaps
, 2005
"... Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstc ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstcase time, n denoting the number of elements stored prior to the operation. These time bounds are valid on a pointer machine as well as on a randomaccess machine. A relaxed weak queue is a collection of at most ⌊lg n ⌋ + 1 perfect weak heaps, where there are in total at most ⌊lg n ⌋ + 1 nodes that may violate weakheap order. In a pointerbased representation of a perfect weak heap, which is a binary tree, it is enough to use two pointers per node to record parentchild relationships. Due to decrease, each node must store one additional pointer. The auxiliary data structures maintained to keep track of perfect weak heaps and potential violation nodes only require O(lg n) words of storage. That is, excluding the space used by the elements themselves, the total space usage of a relaxed weak queue can be as low as 3n + O(lg n) words. ACM CCS Categories and Subject Descriptors. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data Storage Representations]: Linked representations;
The complexity of implicit and spaceefficient priority queues
 Proceedings of the 9th Workshop on Algorithms and Data Structures, Lecture
"... Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and logarithmic time for deletemin. Our second result is a lower bound showing that that one extra word really is necessary. We reduce the decreasekey operation to a cellprobe type game called the Usher's Problem, where one must maintain a simple data structure without the aid of any auxiliary storage.
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...
Putting your data structure on a diet
 In preparation (2006). [Ask Jyrki for details
, 2007
"... Abstract. Consider a data structure D that stores a dynamic collection of elements. Assume that D uses a linear number of words in addition to the elements stored. In this paper several datastructural transformations are described that can be used to transform D into another data structure D ′ that ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract. Consider a data structure D that stores a dynamic collection of elements. Assume that D uses a linear number of words in addition to the elements stored. In this paper several datastructural transformations are described that can be used to transform D into another data structure D ′ that supports the same operations as D, has considerably smaller memory overhead than D, and performs the supported operations by a small constant factor or a small additive term slower than D, depending on the data structure and operation in question. The compaction technique has been successfully applied for linked lists, dictionaries, and priority queues.
Priority Queues and Sorting for ReadOnly Data
"... Abstract. We revisit the randomaccessmachine model in which the input is given on a readonly randomaccess media, the output is to be produced to a writeonly sequentialaccess media, and in addition there is a limited randomaccess workspace. The length of the input is N elements, the length of ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We revisit the randomaccessmachine model in which the input is given on a readonly randomaccess media, the output is to be produced to a writeonly sequentialaccess media, and in addition there is a limited randomaccess workspace. The length of the input is N elements, the length of the output is limited by the computation itself, and the capacity of the workspace is O(S + w) bits,whereS is a parameter specified by the user and w is the number of bits per machine word. We present a stateoftheart priority queue—called an adjustable navigation pile—for this model. Under some reasonable assumptions, our priority queue supports minimum and insert in O(1) worstcase time and extract in O(N/S +lgS) worstcase time, where lg N ≤ S ≤ N / lg N. We also show how to use this data structure to simplify the existing optimal O(N 2 /S + N lg S)time sorting algorithm for this model. 1
SpaceEfficient DataAnalysis Queries on Grids
"... We consider various dataanalysis queries on twodimensional points. We give new space/time tradeoffs over previous work on geometric queries such as dominance and rectangle visibility, and on semigroup and group queries such as sum, average, variance, minimum and maximum. We also introduce new solu ..."
Abstract
 Add to MetaCart
We consider various dataanalysis queries on twodimensional points. We give new space/time tradeoffs over previous work on geometric queries such as dominance and rectangle visibility, and on semigroup and group queries such as sum, average, variance, minimum and maximum. We also introduce new solutions to queries less frequently considered in the literature such as twodimensional quantiles, majorities, successor/predecessor, mode, and various topk queries, considering static and dynamic scenarios.
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.
Chopping Up Trees to Improve Spatial Locality in Implicit kHeaps
"... Abstract. Research on the performance of implicit kheaps has shown that aligning data with cache lines and increasing heap arity are effective techniques for improving the data reference locality of heap operations. The technique of tree blocking has long been used to enhance the data reference loc ..."
Abstract
 Add to MetaCart
Abstract. Research on the performance of implicit kheaps has shown that aligning data with cache lines and increasing heap arity are effective techniques for improving the data reference locality of heap operations. The technique of tree blocking has long been used to enhance the data reference locality of treebased search methods. In this paper we propose cclustered tree blocking, a new tree blocking method designed to further enhance the data reference locality of implicit kheap operations. We examine the effect of our method on the performance of a traditional aligned implicit 2heap using internal memory benchmarks based on the Hold model. Our empirical results, reproduced on four contemporary architectures, show that our method produces speedups of up to 2.0 in either benchmark, while reducing data cache misses by up to 85 % and TLB misses by up to 65%. For larger heap arities our method matches the performance of traditional implicit kheaps while improving page level locality. 1