Joong Chae Na

Truncated suffix trees and their application to data compression

The suffix tree is a fundamental data structure in the area of string algorithms and it has been used in many applications including data compression. In this paper we propose a data structure called the truncated suffix tree, which is a truncated version of the suffix tree. We also present two linear-time construction algorithms for truncated suffix trees and two algorithms that delete suffixes from truncated suffix trees.The truncated suffix tree is particularly a useful data structure for LZ77 that compresses using a sliding window of a fixed size. Our algorithms lead to two implementations of LZ77 that maintain sliding windows by truncated suffix trees. We also present a technique of finding the longest match in a sliding window, which is a crucial step in LZ77.

Efficient implementation of rank and select functions for succinct representation

Succinct representation is a space-efficient method to represent n discrete objects by O(n) bits. In order to access directly the ith object of succinctly represented data structures in constant time, two fundamental functions, rank and select are commonly used. However, little efforts were made on analyzing practical behaviors of these functions despite their importance for succinct representations. In this paper we analyze the behavior of Clarks algorithm which is the only one to support select in constant time using o(n)-bit space of extra space, and show that the performance of Clarks algorithm gets worse as the number of 1s in a bit-string becomes fewer and there exists a worst case in which a large amount of operations are needed. Then, we propose two algorithms that overcome the drawbacks of Clarks. These algorithms take constant time forselect, and one uses o(n) bits for extra space and the other uses n + o(n) bits in the worst case. Experimental results show that our algorithms compute select faster than Clarks.

A fast algorithm for order-preserving pattern matching

We present a new method of deciding the order-isomorphism between two strings.We show that the bad character rule can be applied to the OPPM problem.We present a space-efficient algorithm computing the shift table for text search.We present a linear-time algorithm for an integer alphabet in the worst case. Given a text T and a pattern P, the order-preserving pattern matching (OPPM) problem is to find all substrings in T which have the same relative orders as P. The OPPM has been studied in the fields of finding some patterns affected by relative orders, not by their absolute values. In this paper, we present a method of deciding the order-isomorphism between two strings even when there are same characters. Then, we show that the bad character rule of the Horspool algorithm for generic pattern matching problems can be applied to the OPPM problem and we present a space-efficient algorithm for computing shift tables for text search. Finally, we combine our bad character rule with the KMP-based algorithm to improve the worst-case running time. We give experimental results to show that our algorithm is about 2 to 6 times faster than the KMP-based algorithm in reasonable cases.

Linear-Time construction of compressed suffix arrays using o ( n log n )-bit working space for large alphabets

The suffix array is a fundamental index data structure in string algorithms and bioinformatics, and the compressed suffix array (CSA) and theFM-index are its compressed versions. Many algorithms for constructing these index data structures have been developed. Recently, Hon et al. [11] proposed a construction algorithm using O(n ·loglog|Σ|) time and O(nlog|Σ|)-bit working space, which is the fastest algorithm using O(nlog|Σ|)-bit working space. In this paper we give an efficient algorithm to construct the index data structures for large alphabets. Our algorithm constructs the suffix array, the CSA, and the FM-index using O(n) time and

On-line construction of parameterized suffix trees for large alphabets

O(n \log|\Sigma| \log_{|\Sigma|}^{\;\alpha} n)

Suffix Tree of Alignment: An Efficient Index for Similar Data

-bit working space, where α = log3 2. Our algorithm takes less time and more space than Hon et al.s algorithm. Our algorithm uses least working space among alphabet-independent linear-time algorithms.

Fast Order-Preserving Pattern Matching

We consider on-line construction of the suffix tree for a parameterized string, where we always have the suffix tree of the input string read so far. This situation often arises from source code management systems where, for example, a source code repository is gradually increasing in its size as users commit new codes into the repository day by day. We present an on-line algorithm which constructs a parameterized suffix tree in randomized O(n) time, where n is the length of the input string. Our algorithm is the first randomized linear time algorithm for the on-line construction problem.

Consensus Optimizing Both Distance Sum and Radius

We consider an index data structure for similar strings. The generalized suffix tree can be a solution for this. The generalized suffix tree of two strings A and B is a compacted trie representing all suffixes in A and B. It has |A| + |B| leaves and can be constructed in O(|A| + |B|) time. However, if the two strings are similar, the generalized suffix tree is not efficient because it does not exploit the similarity which is usually represented as an alignment of A and B.

Alphabet-independent linear-time construction of compressed suffix arrays using o( n log n )-bit working space

Given a text T and a pattern P, the order-preserving pattern matching (OPPM) problem is to find all substrings in T which have the same relative orders as P. The OPPM has been studied in the fields of finding some patterns affected by relative orders, not by their absolute values. For example, it can be applied to time series analysis like share prices on stock markets and to musical melody matching of two musical scores. In this paper, we present a new method of deciding the order-isomorphism between two strings even when there are same characters. Then, we show that the bad character rule of the Horspool algorithm for generic pattern matching problems can be applied to the OPPM problem. Finally, we present a fast algorithm for the OPPM problem and give experimental results to show that our algorithm is about 2 to 5 times faster than the KMP-based algorithm in reasonable cases.

Simple Implementation of String B-Trees

The consensus string problem is finding a representative string (consensus) of a given set