Dynamic Z-Fast Tries

@inproceedings{Belazzougui2010DynamicZT,
  title={Dynamic Z-Fast Tries},
  author={Djamal Belazzougui and Paolo Boldi and Sebastiano Vigna},
  booktitle={SPIRE},
  year={2010}
}
We describe a dynamic version of the z-fast trie, a new data structure inspired by the research started by the van Emde Boas trees [12] and followed by the development of y-fast tries [13]. The dynamic z-fast trie is a very simple, uniform data structure: given a set S of n variable-length strings, it is formed by a standard compacted trie on S (with two additional pointers per node), endowed with a dictionary of size n - 1. With this simple setup, the dynamic z-fast trie provides predecessors… 
Faster Dynamic Compact Tries with Applications to Sparse Suffix Tree Construction and Other String Problems
TLDR
The dynamic compact trie data structure can be used to solve online construction of the sparse suffix tree (SST) in O((n= )(f (n) + log )) time and O(n log ) bits for evenly taken space r = (log n) with more general bounds.
Applications of Succinct Dynamic Compact Tries to Some String Problems
TLDR
This paper's recent work on succinct dynamic compact tries that stores a set of strings of total length n in O(n log ) space supporting pattern matching and in- sert/delete operations in O((jPj= )f (n) time) is reported.
c-trie++: A dynamic trie tailored for fast prefix searches
Packed Compact Tries: A Fast and Efficient Data Structure for Online String Processing
TLDR
A new data structure called the packed compact trie (packed c-trie) which stores a set S of k strings of total length n in bits of space and supports fast pattern matching queries and updates and discusses applications.
Top tree compression of tries. (English)
TLDR
A compressed representation of tries based on top tree compression that works on a standard, comparison-based, pointer machine model of computation and supports efficient prefix search queries and develops several interesting data structures that work on a pointer machine and are of independent interest.
Speeding Up Compact Trie Structures on Word RAM and Its Applications
TLDR
This paper presents a faster compact trie for storing a set of K strings with total length N letters in O(N log σ +K logN) bits that supports prefix search (from an arbitrary node) and insert operations in O (⌈P/α⌉ √ w) worst-case time and any linearspace dictionary for integers with fast predecessor and Insert operations, while keeping the linear space.
Top Tree Compression of Tries
TLDR
This work shows how to preprocess a set of strings of total length $n$ over an alphabet of size $\sigma$ into a compressed data structure of worst-case optimal size $O(n/\log_\sigma n)$ that determines if $P$ is a prefix of one of the strings in time $O(\min(m\log \sigma,m + \log n)$.
Packed Compact Tries: A Fast and Efficient Data Structure for Online String Processing
TLDR
The experiments show that the packed c-tries are faster than the standard compact tries and the sparse suffix tree for a string of length $n$ over prefix codes with $k$ sampled positions, such as evenly-spaced and word delimited sparse suffix trees, can be constructed online in worst-case time.
Top Tree Compression of Tries
TLDR
This work presents a compressed representation of tries based on top tree compression that works on a standard, comparison-based, pointer machine model of computation and supports efficient prefix search queries and develops several interesting data structures that work on a pointer machine and are of independent interest.
An In-Depth Analysis of Data Structures Derived from van-Emde-Boas-Trees
TLDR
This thesis gives an overview of several different data structures for the w-bit word RAM on bounded integer universes, i.e. U = {0, . . . , 2 − 1}.
...
1
2
3
...

References

SHOWING 1-10 OF 15 REFERENCES
Dynamic ordered sets with exponential search trees
We introduce exponential search trees as a novel technique for converting static polynomial space search structures for ordered sets into fully-dynamic linear space data structures. This leads to an
The string B-tree: a new data structure for string search in external memory and its applications
TLDR
This work introduces a new text-indexing data structure, the String B-Tree, that can be seen as a link between some traditional external-memory and string-matching data structures that is made more effective by adding extra pointers to speed up search and update operations.
Randomization does not help searching predecessors
TLDR
This paper extends a new technique for proving cell-probe lower bounds for static data structures with deterministic queries to give lower limits for randomized query algorithms with constant error probability, and shows a tight Ω(lg lg n) lower bound for 2-dimensional range queries.
Monotone minimal perfect hashing: searching a sorted table with O(1) accesses
TLDR
This work considers the problem of monotone minimal perfect hashing, in which the bijection is required to preserve the lexicographical ordering of the keys, and shows how to compute the predecessor (in the sorted order of S) of an arbitrary element, using O(1) accesses in expectation and an index of O(n log w) bits.
Dynamic Perfect Hashing: Upper and Lower Bounds
TLDR
Lower bounds for the time complexity of a class of deterministic algorithms for the dictionary problem are proved and this class encompasses realistic hashing-based schemes that use linear space.
Log-Logarithmic Worst-Case Range Queries are Possible in Space Theta(N)
  • D. Willard
  • Computer Science, Mathematics
    Inf. Process. Lett.
  • 1983
Cache-oblivious algorithms
TLDR
It is proved that an optimal cache-oblivious algorithm designed for two levels of memory is also optimal for multiple levels and that the assumption of optimal replacement in the ideal-cache model can be simulated efficiently by LRU replacement.
Linear probing with constant independence
TLDR
It is shown in this paper that linear probing using a pairwise independent family may have expected logarithmic cost per operation, and it is shown that 5-wise independence is enough to ensure constant expected time per operation.
Cuckoo hashing
Bounded Ordered Dictionaries in O(log log N) Time and O(n) Space
...
1
2
...