Managing Unbounded-Length Keys in Comparison-Driven Data Structures with Applications to On-Line Indexing

TL;DR

This paper introduces a versatile technique to adapt comparison-driven data structures for unbounded-length keys, enabling efficient online suffix tree construction and other applications with optimal worst-case performance.

Contribution

The paper presents a general method to handle unbounded-length keys in comparison-based data structures without structural assumptions, achieving worst-case optimal online suffix tree construction.

Findings

Online suffix tree construction in O(log n) worst case per symbol

Efficient pattern searching with O(min(m log |Σ|, m + log n) + tocc) time

Applicability to suffix sorting, LCA, and order maintenance

Abstract

This paper presents a general technique for optimally transforming any dynamic data structure that operates on atomic and indivisible keys by constant-time comparisons, into a data structure that handles unbounded-length keys whose comparison cost is not a constant. Examples of these keys are strings, multi-dimensional points, multiple-precision numbers, multi-key data (e.g.~records), XML paths, URL addresses, etc. The technique is more general than what has been done in previous work as no particular exploitation of the underlying structure of is required. The only requirement is that the insertion of a key must identify its predecessor or its successor. Using the proposed technique, online suffix tree can be constructed in worst case time $O(\log n)$ per input symbol (as opposed to amortized $O(\log n)$ time per symbol, achieved by previously known algorithms). To our knowledge, our algorithm is the first that achieves $O(\log n)$ worst case time per input symbol. Searching for a pattern of length $m$ in the resulting suffix tree takes $O(\min(m\log |\Sigma|, m + \log n) + tocc)$ time, where $tocc$ is the number of occurrences of the pattern. The paper also describes more applications and show how to obtain alternative methods for dealing with suffix sorting, dynamic lowest common ancestors and order maintenance.