J. Ian Munro

Succinct Representation of Balanced Parentheses and Static Trees

We consider the implementation of abstract data types for the static objects: binary tree, rooted ordered tree, and a balanced sequence of parentheses. Our representations use an amount of space within a lower order term of the information theoretic minimum and support, in constant time, a richer set of navigational operations than has previously been considered in similar work. In the case of binary trees, for instance, we can move from a node to its left or right child or to the parent in constant time while retaining knowledge of the size of the subtree at which we are positioned. The approach is applied to produce a succinct representation of planar graphs in which one can test adjacency in constant time.

Representing Trees of Higher Degree

AbstractThis paper focuses on space efficient representations of rooted trees that permit basic navigation in constant time. While most of the previous work has focused on binary trees, we turn our attention to trees of higher degree. We consider both cardinal trees (or k-ary tries), where each node has k slots, labelled {1,...,k}, each of which may have a reference to a child, and ordinal trees, where the children of each node are simply ordered. Our representations use a number of bits close to the information theoretic lower bound and support operations in constant time. For ordinal trees we support the operations of finding the degree, parent, ith child, and subtree size. For cardinal trees the structure also supports finding the child labelled i of a given node apart from the ordinal tree operations. These representations also provide a mapping from the n nodes of the tree onto the integers {1, ..., n}, giving unique labels to the nodes of the tree. This labelling can be used to store satellite information with the nodes efficiently.

Rank/select operations on large alphabets: a tool for text indexing

We consider a generalization of the problem of supporting rank and select queries on binary strings. Given a string of length <i>n</i> from an alphabet of size σ, we give the first representation that supports <i>rank</i> and <i>access</i> operations in <i>O</i>(lg lg σ) time, and <i>select</i> in <i>O</i>(1) time while using the optimal <i>n</i> lg σ + <i>o</i>(<i>n</i> lg σ) bits. The best known previous structure for this problem required <i>O</i>(lg σ) time, for general values of σ. Our results immediately improve the search times of a variety of text indexing methods.

Identifying frequent items in sliding windows over on-line packet streams

Internet traffic patterns are believed to obey the power law, implying that most of the bandwidth is consumed by a small set of heavy users. Hence, queries that return a list of frequently occurring items are important in the analysis of real-time Internet packet streams. While several results exist for computing frequent item queries using limited memory in the infinite stream model, in this paper we consider the limited-memory sliding window model. This model maintains the last

Heaps on heaps

N

Cache-oblivious priority queue and graph algorithm applications

items that have arrived at any given time and forbids the storage of the entire window in memory. We present a deterministic algorithm for identifying frequent items in sliding windows defined over real-time packet streams. The algorithm uses limited memory, requires constant processing time per packet (amortized), makes only one pass over the data, and is shown to work well when tested on TCP traffic logs.

Succinct representations of permutations

As part of a study of the general issue of complexity of comparison based problems, as well as interest in the specific problem, we consider the task of performing the basic priority queue operations on a heap. We show that in the worst case:

Frequency Estimation of Internet Packet Streams with Limited Space

\lg \lg n \pm O(1)

An implicit data structure supporting insertion, deletion, and search in O(log:OS2:OEn) time

comparisons are necessary and sufficient to insert an element into a heap. (This improves the previous upper and lower bounds of

Implicit data structures for fast search and update

\lg n