Results 1  10
of
11
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
Applications of forbidden 01 matrices to search tree and path compression based data structures
, 2009
"... In this paper we improve, reprove, and simplify a variety of theorems concerning the performance of data structures based on path compression and search trees. We apply a technique very familiar to computational geometers but still foreign to many researchers in (nongeometric) algorithms and data s ..."
Abstract

Cited by 6 (5 self)
 Add to MetaCart
In this paper we improve, reprove, and simplify a variety of theorems concerning the performance of data structures based on path compression and search trees. We apply a technique very familiar to computational geometers but still foreign to many researchers in (nongeometric) algorithms and data structures, namely, to bound the complexity of an object via its forbidden substructures. To analyze an algorithm or data structure in the forbidden substructure framework one proceeds in three discrete steps. First, one transcribes the behavior of the algorithm as some combinatorial object M; for example, M may be a graph, sequence, permutation, matrix, set system, or tree. (The size of M should ideally be linear in the running time.) Second, one shows that M excludes some forbidden substructure P, and third, one bounds the size of any object avoiding this substructure. The power of this framework derives from the fact that M lies in a more pristine environment and that upper bounds on the size of a Pfree object M may be reused in different contexts. All of our proofs begin by transcribing the individual operations of a dynamic data structure
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.
Project proposal: A meldable, iteratorvalid priority queue, CPH
, 2005
"... Abstract. The Standard Template Library (STL) is a library of generic algorithms and data structures that has been incorporated in the C++ standard and ships with all modern C++ compilers. In the CPH STL project the goal is to implement an enhanced edition of the STL. The priorityqueue class of the ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract. The Standard Template Library (STL) is a library of generic algorithms and data structures that has been incorporated in the C++ standard and ships with all modern C++ compilers. In the CPH STL project the goal is to implement an enhanced edition of the STL. The priorityqueue class of the STL is just an adapter that makes any resizable array to a queue in which the elements stored are arranged according to a given ordering function. In the C++ standard no compulsory support for the operations delete(), increase(), or meld() is demanded even if those are utilized in many algorithms solving graphtheoretic or geometric problems. In this project, the goal is to implement a CPH STL extension of the priorityqueue class which provides, in addition to the normal priorityqueue functionality, the operations delete(), increase(), and meld(). To make the first two of these operations possible, the class must also guarantee that external references to compartments inside the data structure are kept valid at all times.
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.
Don’t Rush into a Union: Take Time to Find Your Roots
, 2011
"... We present a new threshold phenomenon in data structure lower bounds where slightly reduced update times lead to exploding query times. Consider incremental connectivity, letting tU be the time to insert an edge and tq be the query time. For tU = Ω(tq), the problem is equivalent to the wellundersto ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We present a new threshold phenomenon in data structure lower bounds where slightly reduced update times lead to exploding query times. Consider incremental connectivity, letting tU be the time to insert an edge and tq be the query time. For tU = Ω(tq), the problem is equivalent to the wellunderstood union–find problem: INSERTEDGE(s, t) can be implemented by UNION(FIND(s), FIND(t)). This gives worstcase time tU = tq = O(lg n / lg lg n) and amortized tU = tq = O(α(n)). By contrast, we show that if tU = o(lg n / lg lg n), the query time explodes to tq ≥ n 1−o(1). In other words, if the data structure doesn’t have time to find the roots of each disjoint set (tree) during edge insertion, there is no effective way to organize the information! For amortized complexity, we demonstrate a new inverseAckermann type tradeoff in the regime tU = o(tq). A similar lower bound is given for fully dynamic connectivity, where an update time of o(lg n) forces the query time to be n 1−o(1). This lower bound allows for amortization and Las Vegas randomization, and comes close to the known O(lg n · (lg lg n) O(1) ) upper bound. 1
Melding Priority Queues
 In Proc. of 9th SWAT
, 2004
"... We show that any priority queue data structure that supports insert, delete, and findmin operations in pq(n) time, when n is an upper bound on the number of elements in the priority queue, can be converted into a priority queue data structure that also supports fast meld operations with essentially ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We show that any priority queue data structure that supports insert, delete, and findmin operations in pq(n) time, when n is an upper bound on the number of elements in the priority queue, can be converted into a priority queue data structure that also supports fast meld operations with essentially no increase in the amortized cost of the other operations. More specifically, the new data structure supports insert, meld and findmin operations in O(1) amortized time, and delete operations in O(pq(n) + α(n, n)) amortized time, where α(m, n) is a functional inverse of the Ackermann function. The construction is very simple, essentially just placing a nonmeldable priority queue at each node of a unionfind data structure. We also show that when all keys are integers in the range [1, N], we can replace n in the bound stated above by min{n, N}. Applying this result to nonmeldable priority queue data structures obtained recently by Thorup, and by Han and Thorup, we obtain meldable RAM priority queues with O(log log n) amortized cost per operation, or O ( √ log log n) expected amortized cost per operation, respectively. As a byproduct, we obtain improved algorithms for the minimum directed spanning tree problem in graphs with integer edge weights: A deterministic O(m log log n) time algorithm and a randomized O(m √ log log n) time algorithm. These bounds improve, for sparse enough graphs, on the O(m + n log n) running time of an algorithm by Gabow, Galil, Spencer and Tarjan that works for arbitrary edge weights.
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.
Path Minima Queries in Dynamic Weighted Trees
"... Abstract. In the path minima problem on trees each tree edge is assigned a weight and a query asks for the edge with minimum weight on a path between two nodes. For the dynamic version of the problem on a tree, where the edgeweights can be updated, we give comparisonbased and RAM data structures th ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Abstract. In the path minima problem on trees each tree edge is assigned a weight and a query asks for the edge with minimum weight on a path between two nodes. For the dynamic version of the problem on a tree, where the edgeweights can be updated, we give comparisonbased and RAM data structures that achieve optimal query time. These structures support inserting a node on an edge, inserting a leaf, and contracting edges. When only insertion and deletion of leaves in a tree are needed, we give two data structures that achieve optimal and significantly lower query times than when updating the edgeweights is allowed. One is a semigroup structure for which the edgeweights are from an arbitrary semigroup and queries ask for the semigroupsum of the edgeweights on a given path. For the other structure the edgeweights are given in the word RAM. We complement these upper bounds with lower bounds for different variants of the problem. 1
Abstract On the Power of Structural Violations in Priority Queues
"... We give a priority queue that guarantees the worstcase cost of Θ(1) per minimum finding, insertion, and decrease; and the worstcase cost of Θ(lg n) with at most lg n + O ( √ lg n) element comparisons per deletion. Here, n denotes the number of elements stored in the data structure prior to the ope ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We give a priority queue that guarantees the worstcase cost of Θ(1) per minimum finding, insertion, and decrease; and the worstcase cost of Θ(lg n) with at most lg n + O ( √ lg n) element comparisons per deletion. Here, n denotes the number of elements stored in the data structure prior to the operation in question, and lg n is a shorthand for max {1,log 2 n}. In contrast to a runrelaxed heap, which allows heaporder violations, our priority queue relies on structural violations. By mimicking a priority queue that allows heaporder violations with one that only allows structural violations, we improve the bound on the number of element comparisons per deletion to lg n + O(lg lg n).