Results 11 
18 of
18
Compact Data Structures with Fast Queries
, 2005
"... Many applications dealing with large data structures can benefit from keeping them in compressed form. Compression has many benefits: it can allow a representation to fit in main memory rather than swapping out to disk, and it improves cache performance since it allows more data to fit into the c ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
Many applications dealing with large data structures can benefit from keeping them in compressed form. Compression has many benefits: it can allow a representation to fit in main memory rather than swapping out to disk, and it improves cache performance since it allows more data to fit into the cache. However, a data structure is only useful if it allows the application to perform fast queries (and updates) to the data.
Efficient data flow analysis using DJgraphs: Elimination methods revisited
, 1995
"... In this paper we present a new approach to elimination based data flow analysis that uses a program representation called the DJ Graph. The skeleton of the DJ graph of a program is the dominator tree of its flowgraph (whose edges are called D edges in this paper), and the tree skeleton is augmented ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
In this paper we present a new approach to elimination based data flow analysis that uses a program representation called the DJ Graph. The skeleton of the DJ graph of a program is the dominator tree of its flowgraph (whose edges are called D edges in this paper), and the tree skeleton is augmented with join edges (called J edges in this paper). Unlike the previous elimination methods, which first reduce a flowgraph to a single node, our approach only eliminate J edges from the DJ graph in a bottomup fashion during the reduction process, while maintainting the dominator tree structure (which may be compressed). We propose two methods for eliminating variables: (1) eager elimination method, and (2) delayed elimination method. With eager elimination, we first perform variable elimination on the DJgraph in a bottomup manner. Once we determine the solution for the root node, we propagate this information in a topdown fashion on the dominator tree and determine the corresponding solutio...
Simple Confluently Persistent Catenable Lists.
, 1999
"... Abstract We consider the problem of maintaining persistent lists subject to concatenation and to insertions and deletions at both ends. Updates to a persistent data structure are nondestructive each operation produces a new list incorporating the change, while keeping intact the list or lists to wh ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract We consider the problem of maintaining persistent lists subject to concatenation and to insertions and deletions at both ends. Updates to a persistent data structure are nondestructive each operation produces a new list incorporating the change, while keeping intact the list or lists to which it applies. Although general techniques exist for making data structures persistent, these techniques fail for structures that are subject to operations, such as catenation, that combine two or more versions. In this paper we develop a simple implementation of persistent doubleended queues with catenation that supports all deque operations in constant amortized time. Our implementation is functional if we allow memoization.
HewlettPackard Company and
"... In this article, we present a new framework for eliminationbased exhaustive and incremental data ow analysis using the DJ graph representation of a program. Unlike previous approaches to eliminationbased incremental data
ow analysis, our approach can handle arbitrary structural and nonstructural ..."
Abstract
 Add to MetaCart
(Show Context)
In this article, we present a new framework for eliminationbased exhaustive and incremental data ow analysis using the DJ graph representation of a program. Unlike previous approaches to eliminationbased incremental data
ow analysis, our approach can handle arbitrary structural and nonstructural changes to program
owgraphs, including irreducibility. We show how our approach is related to dominance frontiers, and we exploit this relationship to establish the complexity of our exhaustive analysis and to aid the design of our incremental analysis.
A note on meldable heaps relying on datastructural bootstrapping∗
"... Abstract. We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structur ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structure is asymptotically optimal and nearly constantfactor optimal with respect to the comparison complexity of all the meldableheap operations. Furthermore, the data structure is also simple and elegant. 1.
Sequence Implementations in Haskell
, 1997
"... An abstract data type sequence is defined with the operations empty, isEmpty, cons, snoc, popFront, popRear, lenghtSeq, toList, and toSeq. A sequence with the operations lookupSeq and updateSeq is an Indexable Sequence. A sequence with catenation is called a Catenable Sequence. Some functional imp ..."
Abstract
 Add to MetaCart
(Show Context)
An abstract data type sequence is defined with the operations empty, isEmpty, cons, snoc, popFront, popRear, lenghtSeq, toList, and toSeq. A sequence with the operations lookupSeq and updateSeq is an Indexable Sequence. A sequence with catenation is called a Catenable Sequence. Some functional implementations of these abstract data types taken from the literature are described. These implementations are classified as stacks, deques, flexible arrays, and catenable lists, if they can be used as efficient implementations for each of these traditional data types. Some of them are extended to provide the operations defined for sequences. Some comments and directions for further research are also included. The implementations are made in the functional programming language Haskell as instances of one or more of the classes Sequence, IndSeq, and CatSeq, with the operations defined for each type. These instances are classified by the subset of these operations that each instance supports eff...
and the Deque Conjecture
"... We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence, none of whose subsequences are isomorphic to a fixed forbidden subsequence. We direct ..."
Abstract
 Add to MetaCart
(Show Context)
We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence, none of whose subsequences are isomorphic to a fixed forbidden subsequence. We direct this technique towards Tarjan’s deque conjecture and prove that n deque operations take only O(nα ∗ (n)) time, where α ∗ (n) is the minimum number of applications of the inverseAckermann function mapping n to a constant. We are optimistic that this approach could be directed towards other open conjectures on splay trees such as the traversal and split conjectures. 1
Gurgaon,India Gurgaon,India
"... Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worstcase time, and delete Min in O(log n) worstcase time. These bounds are asymptotically optimal among all comparisonbased priority queues. In this paper, we adapt Brod ..."
Abstract
 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 delete Min 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 find Min 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. 1.