Compact Encodings of List Structure

WALCOM: Algorithms and Computation, 2015

In recent years, there has been an explosion of interest in succinct data structures, which store the given data in compact or compressed formats and answer queries on the data rapidly while it is still in its compressed format. Our focus in this talk is to introduce encoding data structures. Encoding data structures consider the data together with the queries and aim to store only as much information about the data as is needed to store the queries. Once this is done, the original data can be deleted. In many cases, one can obtain space-efficient encoding data structures even when the original data is incompressible.

Combinatorial Pattern Matching, 2011

LRM-Trees are an elegant way to partition a sequence of values into sorted consecutive blocks, and to express the relative position of the first element of each block within a previous block. They were used to encode ordinal trees and to index integer arrays in order to support range minimum queries on them. We describe how they yield many other convenient results in a variety of areas, from data structures to algorithms: some compressed succinct indices for range minimum queries; a new adaptive sorting algorithm; and a compressed succinct data structure for permutations supporting direct and indirect application in time all the shortest as the permutation is compressible. As part of our review preliminary work, we also give an overview of the, sometimes redundant, terminology relative to succinct data-structures and indices.

2007

We present a framework to dynamize succinct data structures, to encourage their use over non-succinct versions in a wide variety of important application areas. Our framework can dynamize most state-of-the-art succinct data structures for dictionaries, ordinal trees, labeled trees, and text collections. Of particular note is its direct application to XML indexing structures that answer subpath queries [2]. Our framework focuses on achieving information-theoretically optimal space along with near-optimal update/query bounds. As the main part of our work, we consider the following problem central to text indexing: Given a text T over an alphabet Σ, construct a compressed data structure answering the queries char(i), rank s (i), and select s (i) for a symbol s ∈ Σ. Many data structures consider these queries for static text T [5,3,16,4]. We build on these results and give the best known query bounds for the dynamic version of this problem, supporting arbitrary insertions and deletions of symbols in T. Specifically, with an amortized update time of O(n ε ), any static succinct data structure D for T, taking t(n) time for queries, can be converted by our framework into a dynamic succinct data structure that supports rank s (i), select s (i), and char(i) queries in O(t(n) + loglogn) time, for any constant ε> 0. When |Σ| = polylog(n), we achieve O(1) query times. Our update/query bounds are near-optimal with respect to the lower bounds from [13].

2006

We propose measures for compressed data structures, in which space usage is measured in a data-aware manner. In particular, we consider the fundamental dictionary problem on set data, where the task is to construct a data structure to represent a set S of n items out of a universe U = {0, . . . , u − 1} and support various queries on S. We use a well-known data-aware measure for set data called gap to bound the space of our data structures.

2014 Data Compression Conference, 2014

List update is a key step during the Burrows-Wheeler transform (BWT) compression. Previous work has shown (e.g., ]) that careful study of the list update step leads to better BWT compression. Surprisingly, the theoretical study of list update algorithms for compression has lagged behind its use in real practice. To be more precise, the standard model by Sleator and Tarjan for list update considers a linear cost-of-access model while compression incurs a logarithmic cost of access, i.e. accessing item i in the list has cost Θ(i) in the standard model but Θ(log i) in compression applications 1 . These models have been shown, in general, not to be equivalent . This paper has two contributions:

String Processing and Information Retrieval, 2008

A repetitive sequence collection is one where portions of a base sequence of length n are repeated many times with small variations, forming a collection of total length N. Examples of such collections are version control data and genome sequences of individuals, where the differences can be expressed by lists of basic edit operations. This paper is devoted to studying ways to store massive sets of highly repetitive sequence collections in space-efficient manner so that retrieval of the content as well as queries on the content of the sequences can be provided time-efficiently. We show that the state-of-the-art entropy-bound full-text self-indexes do not yet provide satisfactory space bounds for this specific task. We engineer some new structures that use run-length encoding and give empirical evidence that these structures are superior to the current structures.

Lecture Notes in Computer Science, 2014

Engineering efficient implementations of compact and succinct structures is a time-consuming and challenging task, since there is no standard library of easy-touse, highly optimized, and composable components. One consequence is that measuring the practical impact of new theoretical proposals is a difficult task, since older baseline implementations may not rely on the same basic components, and reimplementing from scratch can be very time-consuming. In this paper we present a framework for experimentation with succinct data structures, providing a large set of configurable components, together with tests, benchmarks, and tools to analyze resource requirements. We demonstrate the functionality of the framework by recomposing succinct solutions for document retrieval.

Using doubly linked list in embedded systems can be expensive. Although doubly linked is efficient in terms of time complexity and highly flexible in itself, enabling easy traversal and update, but it often demands more memory space compared to other list data strucurethis is as a result of the space required for the extra pointers, doubling the amount needed for a singly linked list. In this paper, we introduce the S-linked lista hybrid of the concept of the singly linked list and the circular linked list. The hybrid gives a data structure that is similar to the unrolled linked list, but rather than have an array in each node, we have a singly linked list. An analysis of the space complexity and assymptotic time complexity of the algorithm was carried out.

Here, I have introduced a new data structure titled "Array-Linked Data Structure". It incorporates a hybrid model of memory allocation, introducing a new insertion procedure in an existing data structure which is faster than that for arrays. It also offers O(c) access time where c is a constant. The access time is worse than O(1) for an array but still better than that for a linked list since the index of data could be directly supplied to the access procedure here. The data structure also maintains a DS table for each allocated block of memory which keeps track of auxiliary data structures in the main block. Insert call of the structure offers a complexity of O(t*log(t)) where t is the number of auxiliary data chains in the main block where insertion is supposed to happen. Rest of the procedures are discussed in detail with proofs. The main element of the structure is that it offers a faster insertion procedure and easier reallocation procedure, while maintaining a hybrid model of contiguous memory allocation