Kao M.-Y. (ed.) Encyclopedia of Algorithms

Подождите немного. Документ загружается.

918 S Succinct Encoding of Permutations: Applications to Text Indexing

Succinct Encoding of Permutations: Applications to Text Indexing, Figure 2

A function on f1;:::;13g, with three cycles and two nontrivial tree structures

and string_succ

for any literal ˛ 2 [l] [ [

l] in

O(lg

(2)

l  lg

(3)

l  ( f (n; t)+lg

(2)

l)) time, and the opera-

tor string_select

for any label ˛ 2 [l] in O(lg

(3)

l 

(f (n; t)+lg

(2)

l)) time.

The separation between the encoding of the string or of

an XML-like document and its index has two main advan-

tages:

1. The string can now be compressed and searched at the

same time, provided that the compressed encoding of

the string supports the access in reasonable time, as

does the one described by Ferragina and Venturini [3].

2. The operators can be supported for several orderings

of the string, for instance, induced by distinct traver-

sals of a labeled tree, with only a small cost in space.

It is important, for instance, when those orders corre-

spond to various traversals of a labeled structure, such

as the depth-ﬁrst and Depth First Uniary Degree Se-

quence (DFUDS) traversals of a labeled tree [2].

Binary Relations

Given two ordered sets of sizes l and n, denoted by [l]and

[n], a binary relation R between these sets is a subset of

their Cartesian product, i. e., R  [l][n]. It is used, for

instance, to represent the relation between a set of labels

[l] and a set of objects [n].

Although a string can be seen as a particular case of

a binary relation, where the objects are positions and ex-

actly one label is associated with each position, the search

operations on binary relations are diverse, including oper-

ators on both the labels and the objects. For any literal ˛,

object x and integer r, consider the following operators:

 label_rank

(˛; x): the number of objects labeled ˛

preceding or equal to x;

 label_select

(˛; r): the position of the rth object

labeled ˛ if any, or 1 otherwise;

 label_nb

(˛), the number of objects with label ˛;

 object_rank

(x;˛): the number of labels associ-

ated with object x preceding or equal to label ˛;

 object_select

(x; r): the rth label associated with

object x,ifany,or1 otherwise;

 object_nb

(x): the number of labels associated with

object x;

 table_access

(x;˛): checks whether object x is

associated with label ˛.

Barbay et al. [1] observed that such a binary relation, con-

sisting of t pairs from [n]  [l], can be encoded as a text

string S listing the t labels, and a binary string B indicating

how many labels are associated with each object. So search

operations on the objects associated with a ﬁxed label are

reduced to a combination of operators on text and binary

strings. Using a more direct reduction to the encoding of

permutations, the index of the binary relation can be sep-

arated from its encoding, and even more operators can be

supported [2].

Theorem 5 (Barbay et al. [2]) Given support for

object_access

in f (n; l; t) time on a binary relation

formed by t pairs from an object set [n] and a label set [l],

there is a succinct index using t(1 + o(lg l)) bits that sup-

ports label_rank

for any literal ˛ 2 [l] [ [

l] and

label_access

for any label ˛ 2 [l] in O(lg

(2)

l lg

(3)

l 

(f (n; l; t)+lg

(2)

l)) time, and label_select

for any

label ˛ 2 [l] in O(lg

(3)

l ( f (n; l; t)+lg

(2)

l)) time.

To conclude this entry, note that a labeled tree T can be

represented by an ordinal tree coding its structure [6]and

astringS listing the labels of the nodes. If the labels are

listed in preorder (respectively in DFUDS order) the oper-

ator string_succ

enumerates all the descendants (re-

spectively children) of a node matching some literal ˛.Us-

ing succinct indexes, a single encoding of the labels and

the support of a permutation between orders is suﬃcient

to implement both enumerations, and other search opera-

tors on the labels. These issues, along with strings and la-

Suffix Array Construction S 919

beled trees compression techniques which achieve the en-

tropy of the indexed data, are covered in more detail in the

entries cited in  Tree Compression and Indexing.

Cross References

 Compressed Suﬃx Array

 Compressed Text Indexing

 Rank and Select Operations on Binary Strings

 Text Indexing

Recommended Reading

1. Barbay, J., Golynski, A., Munro, J.I., Rao, S.S.: Adaptive search-

ing in succinctly encoded binary relations and tree-structured

documents. In: Proceedings of the 17th Annual Symposium

on Combinatorial Pattern Matching (CPM). Lecture Notes in

Computer Science (LNCS), vol. 4009, pp. 24–35. Springer, Berlin

(2006)

2. Barbay, J., He, M., Munro, J.I., Rao, S.S.: Succinct indexes for

strings, binary relations and multi-labeled trees. In: Proceed-

ings of the 18th ACM-SIAM Symposium on Discrete Algorithms

(SODA), pp. 680–689. ACM, SIAM (2007)

3. Ferragina, P., Venturini, R.: A simple storage scheme for strings

achieving entropy bounds. In: Proceedings of the 18th ACM-

SIAM Symposium on Discrete Algorithms (SODA), pp. 690–695.

ACM, SIAM (2007)

4. Golynski, A., Munro, J.I., Rao, S.S.: Rank/select operations on

large alphabets: a tool for text indexing. In: Proceedings of

the 17th Annual ACM-SIAM Symposium on Discrete Algorithms

(SODA), pp. 368–373. ACM, SIAM (2006)

5. Jacobson, G.: Space-efficient static trees and graphs. In: Pro-

ceedings of the 30th IEEE Symposium on Foundations of Com-

puter Science (FOCS), pp. 549–554 (1989)

6. Jansson, J., Sadakane, K., Sung, W.-K.: Ultra-succinct represen-

tation of ordered trees. In: Proceedings of the 18th ACM-SIAM

Symposium on Discrete Algorithms (SODA), pp. 575–584. ACM,

SIAM (2007)

7. Munro,J.I.,Raman,R.,Raman,V.,Rao,S.S.:Succinctrepresen-

tations of permutations. In: Proceedings of the 30th Interna-

tional Colloquium on Automata, Languages and Programming

(ICALP). Lecture Notes in Computer Science (LNCS), vol. 2719,

pp. 345–356. Springer, Berlin (2003)

8. Munro, J.I., Raman, V.: Succinct representation of balanced

parentheses and static trees. SIAM J. Comput. 31, 762–776

(2001)

9. Munro, J.I., Rao, S.S.: Succinct representations of functions. In:

Proceedings of the International Colloquium on Automata, Lan-

guages and Programming (ICALP). Lecture Notes in Computer

Science (LNCS), vol. 3142, pp. 1006–1015. Springer, Berlin (2004)

Suffix Array Construction

2006; Kärkkäinen, Sanders, Burkhardt

JUHA KÄRKKÄINEN

Department of Computer Science, University of Helsinki,

Helsinki, Finland

Keywords and Synonyms

Suﬃx sorting; Full-text index construction

Problem Definition

The suﬃx array [5,14] is the lexicographically sorted array

of all the suﬃxes of a string. It is a popular text index struc-

ture with many applications. The subject of this entry are

algorithms that construct the suﬃx array.

More precisely, the input to a suﬃx array construc-

tion algorithm is a text string T = T[0; n)=t

t

n1

i. e., a sequence of ncharactersfrom an alphabet ˙.For

i 2 [0; n], let S

denote the suﬃx T[i; n)=t

i+1

t

n1

The output is the suﬃx array SA[0; n]ofT,apermutation

of [0; n] satisfying S

SA[0]

< S

SA[1]

< < S

SA[n]

,where

< denotes the lexicographic order of strings.

Two speciﬁc models for the alphabet ˙ are considered.

An ordered alphabet is an arbitrary ordered set with con-

stant time character comparisons. An integer alphabet is

the integer range [1; n]. There is also a result that holds for

any alphabet.

Many applications require that the suﬃx array is aug-

mented with additional information, most commonly with

the longest common preﬁx array LCP[0; n). An entry

LCP[i] of the LCP array is the length of the longest com-

mon preﬁx of the suﬃxes S

SA[i]

and S

SA[i+1]

.Theen-

hanced suﬃx array [1] adds two more arrays to obtain

a full range of text index functionalities.

Another related array, the Burrows–Wheeler transform

BW T[0; n) is often computed by suﬃx array construc-

tion using the equations BWT[i]=T[SA[i]  1] when

SA[i] ¤ 0andBW T[i]=T[n  1] when SA[i]=0.

There are other important text indexes, most notably

suﬃx trees and compressed text indexes, covered in sep-

arate entries. Each of these indexes have their own con-

struction algorithms, but they can also be constructed eﬃ-

ciently from each other. However, in this entry, the focus is

on direct suﬃx array construction algorithms that do not

rely on other text indexes.

Key Results

The naive approach to suﬃx array construction is to use

a general sorting algorithm or an algorithm for sorting

strings. However, any such algorithm has a worst-case

time complexity ˝(n

) because the total length of the suf-

ﬁxes is ˝(n

The ﬁrst eﬃcient algorithms were based on the dou-

bling technique of Karp, Miller, and Rosenberg [8]. The

idea is to assign a rank to all substrings whose length is

a power of two. The rank tells the lexicographic order of

920 S Suffix Array Construction

the substring among substrings of the same length. Given

the ranks for substrings of length h,theranksforsub-

strings of length 2h can be computed using a radixsort step

in linear time (doubling). The technique was ﬁrst applied

to suﬃx array construction by Manber and Myers [14].

The best practical algorithm based on the technique is by

Larsson and Sadakane [13].

Theorem 1 (Manber and Myers [14]; Larsson and

Sadakane [13]) The suﬃx array can be constructed in

O(n log n) worst-case time, which is optimal for the ordered

alphabet.

Faster algorithms for the integer alphabet are based on

a diﬀerent technique, recursion. The basic procedure is as

follows.

1. Sort a subset of the suﬃxes. This is done by construct-

ing a shorter string, whose suﬃx array gives the order of

the desired subset. The suﬃx array of the shorter string

is constructed by recursion.

2. Extend the subset order to full order.

The technique ﬁrst appeared in suﬃx tree construction [4],

but 2003 saw the independent and simultaneous publica-

tion of three linear time suﬃx array construction algo-

rithms based on the approach but not using suﬃx trees.

Each of the three algorithms uses a diﬀerent subset of suf-

ﬁxes requiring a diﬀerent implementation of the second

step.

Theorem 2 (Kärkkäinen, Sanders and Burkhardt [7];

Kim el al. [10]; Ko and Aluru [11]) The suﬃx array can

be constructed in the optimal linear time for the integer al-

phabet.

The algorithm of Kärkkäinen, Sanders, and Burkhardt [7]

has generalizations for several parallel and hierarchical

memory models of computation including an optimal al-

gorithm for external memory and a linear work algorithm

for the BSP model.

The above algorithms and many other suﬃx array con-

struction algorithms are surveyed in [18].

The ˝(n log n) lower bound for the ordered alphabet

mentioned in Theorem 1 comes from the sorting complex-

ity of characters, since the initial characters of the sorted

suﬃxes are the text characters in sorted order. Theorem 2

allows a generalization of this result. For any alphabet, one

canﬁrstsortthecharactersofT,removeduplicates,as-

sign a rank to each character, and construct a new string

over the alphabet [1; n] by replacing the characters of T

with their ranks. The suﬃx array of T

is exactly the same

as the suﬃx array of T. Optimal algorithms for the integer

alphabet then give the following result.

Theorem 3 For any alphabet, the complexity of suﬃx ar-

ray construction is the same as the complexity of sorting the

characters of the string.

The result extends to the related arrays.

Theorem 4 (Kasai et al. [9]; Abouelhoda, Kurtz and

Ohlebusch [1]) The LCP array, the enhanced suﬃx ar-

ray, and the BWT can be computed in linear time given the

suﬃx array.

One of the main advantages of suﬃx arrays over suﬃx

trees is their smaller space requirement (by a constant

factor), and a signiﬁcant eﬀort has been spent making

construction algorithms space eﬃcient, too. A technique

based on the notion of diﬀerence covers gives the following

results.

Theorem 5 (Burkhardt and Kärkkäinen [2]; Kärkkäi-

nen, Sanders and Burkhardt [7]) For any v =

O(n

2/3

the suﬃx array can be constructed in

O(n(v +logn)) time

for the ordered alphabet and in

O(nv) time for the integer

alphabet using

O(n/

v) space in addition to the input (the

string T) and the output (the suﬃx array).

Kärkkäinen [6] uses the diﬀerence cover technique to con-

struct the suﬃx array in blocks without ever storing the

full suﬃx array obtaining the following result for comput-

ing the BWT.

Theorem 6 (Kärkkäinen [6]) For any v =

O(n

2/3

),the

BWT can be constructed in

O(n(v +logn)) time for the or-

dered alphabet using

O(n/

v) space in addition to the in-

put (the string T) and the output (the BWT).

Compressed text index construction algorithms are alter-

natives to space-eﬃcient BWT computation.

Applications

The suﬃx array is a simple and powerful text index struc-

ture with numerous applications detailed in the entry Text

Indexing. In addition, due to the existence of eﬃcient and

practical construction algorithms, the suﬃx array is often

used as an intermediate data structure in computing some-

thing else. The BWT is usually computed from the suﬃx

array and has applications in text compression and com-

pressed index construction. The suﬃx tree is also easy to

construct given the suﬃx array and the LCP array.

Open Problems

Theoretically, the suﬃx array construction problem is es-

sentially solved. The development of ever more eﬃcient

Suffix Array Construction S 921

practical algorithms is still going on with several diﬀerent

nontrivial heuristics available [18] including very recent

ones [15].

Experimental Resul t s

An experimental comparison of a large number of suﬃx

array construction algorithms is presented in [18]. The

best algorithms in the comparison are the algorithm by

Maniscalco and Puglisi [15], which is the fastest but has

an ˝(n

) worst-case complexity, and a variant of the al-

gorithm by Burkhardt and Kärkkäinen [2], which is the

fastest among algorithms with good worst-case complex-

ity. Both algorithms are also space eﬃcient. The algorithm

of Manzini and Ferragina [17] is still slightly more space

eﬃcient and also very fast in practice.

There are also experiments with parallel [12]andex-

ternal memory algorithms [3]. Variants of the algorithm

by Kärkkäinen, Sanders and Burkhardt [7]showhighper-

formance and scalability in both cases.

Algorithms for computing the LCP array from the suf-

ﬁx array are compared in [16].

Data Sets

The input to a suﬃx array construction algorithm is sim-

ply a text, so an abundance of data exists. Commonly used

text collections include the Canterbury Corpus at http://

corpus.canterbury.ac.nz/, the corpus compiled by Manzini

and Ferragina at http://www.mfn.unipmn.it/~manzini/

lightweight/corpus/, and the Pizza&Chili Corpus at http://

pizzachili.dcc.uchile.cl/texts.html.

URL to Code

The implementations of many of the algorithms men-

tioned here are publicly available, for example: http://

www.larsson.dogma.net/research.html [13], http://www.

mpi-sb.mpg.de/~sanders/programs/suﬃx/ [7], and http://

www.cs.helsinki.ﬁ/juha.karkkainen/publications/cpm03.

tar.gz [2]. Manzini provides a package that computes the

LCP array and the BWT, too, at http://www.mfn.unipmn.

it/~manzini/lightweight/index.html.Thebzip2 com-

pression program (http://www.bzip.org/)computesthe

BWT through suﬃx array construction.

Cross References

 Compressed Suﬃx Array

 Compressed Text Indexing

 String Sorting

 Suﬃx Tree Construction in Hierarchical Memory

 Suﬃx Tree Construction in RAM

 Text Indexing

 Two-Dimensional Pattern Indexing

Recommended Reading

1. Abouelhoda, M.I., Kurtz, S., Ohlebusch, E.: Replacing suffix trees

with enhanced suffix arrays. J. Discret. Algorithms 2, 53–86

(2004)

2. Burkhardt, S., Kärkkäinen, J.: Fast lightweight suffix array con-

struction and checking. In: Proc. 14th Annual Symposium on

Combinatorial Pattern Matching. LNCS, vol. 2676, pp. 55–69.

Springer, Berlin/Heidelberg (2003)

3. Dementiev,R.,Mehnert,J.,Kärkkäinen,J.,Sanders,P.:Betterex-

ternal memory suffix array construction. ACM J. Exp. Algorith-

mics (2008) in press

4. Farach-Colton, M., Ferragina, P., Muthukrishnan, S.: On the

sorting-complexity of suffix tree construction. J. Assoc. Com-

put. Mach. 47, 987–1011 (2000)

5. Gonnet, G., Baeza-Yates, R., Snider, T.: New indices for text: PAT

trees and PAT arrays. In: Frakes, W.B., Baeza-Yates, R. (eds.) In-

formation Retrieval: Data Structures & Algorithms. pp. 66–82

Prentice-Hall, Englewood Cliffs (1992)

6. Kärkkäinen, J.: Fast BWT in small space by blockwise suffix sort-

ing. Theor. Comput. Sci. 387, 249–257 (2007)

7. Kärkkäinen,J.,Sanders,P.,Burkhardt,S.:Linearworksuffixar-

ray construction. J. Assoc. Comput. Mach. 53, 918–936 (2006)

8. Karp, R.M., Miller, R.E., Rosenberg, A.L.: Rapid identification of

repeated patterns in strings, trees and arrays. In: Proc. 4th An-

nual ACM Symposium on Theory of Computing, pp. 125–136.

ACM Press, New York (1972)

9.Kasai,T.,Lee,G.,Arimura,H.,Arikawa,S.,Park,K.:Linear-

time longest-common-prefix computation in suffix arrays and

its applications. In: Proc. 12th Annual Symposium on Combi-

natorial Pattern Matching, vol. (2089) of LNCS. pp. 181–192.

Springer, Berlin/Heidelberg (2001)

10. Kim,D.K.,Sim,J.S.,Park,H.,Park,K.:Constructingsuffixarrays

in linear time. J. Discret. Algorithms 3, 126–142 (2005)

11. Ko, P., Aluru, S.: Space efficient linear time construction of suffix

arrays.J.Discret.Algorithms3, 143–156 (2005)

12. Kulla, F., Sanders, P.: Scalable parallel suffix array construction.

In: Proc. 13th European PVM/MPI User’s Group Meeting. LNCS,

vol. 4192, pp. 22–29. Springer, Berlin/Heidelberg (2006)

13. Larsson, N.J., Sadakane, K.: Faster suffix sorting. Theor. Comput.

Sci. 387, 258–272 (2006)

14. Manber, U., Myers, G.: Suffix arrays: A new method for on-line

string searches. SIAM J. Comput. 22, 935–948 (1993)

15. Maniscalco, M.A., Puglisi, S.J.: Faster lightweight suffix ar-

ray construction. In: Proc. 17th Australasian Workshop on

Combinatorial Algorithms, pp. 16–29. Univ. Ballavat, Ballavat

(2006)

16. Manzini, G.: Two space saving tricks for linear time LCP ar-

ray computation. In: Proc. 9th Scandinavian Workshop on

Algorithm Theory. LNCS, vol. 3111, pp. 372–383. Springer,

Berlin/Heidelberg (2004)

17. Manzini, G., Ferragina, P.: Engineering a lightweight suffix array

construction algorithm. Algorithmica 40, 33–50 (2004)

18. Puglisi, S., Smyth, W., Turpin,A.: A taxonomy of suffix array con-

struction algorithms. ACM Comput. Surv. 39(2), Article 4, 31

pages (2007)

922 S Suffix Tree Construction in Hierarchical Memory

Suffix Tree Construction

in Hierarchical Memory

2000; Farach-Colton, Ferragina, Muth ukrishnan

PAOLO FERRAGINA

Department of Computer Science, University of Pisa,

Pisa, Italy

Keywords and Synonyms

Suﬃx array construction; String B-tree construction; Full-

text index construction

Problem Definition

The suﬃx tree is the ubiquitous data structure of combi-

natorial pattern matching because of its elegant uses in

a myriad of situations–-just to cite a few, searching, data

compression and mining, bioinformatics [6]. In these ap-

plications, the large data sets now available involve the

use of numerous memory levels which constitute the stor-

age medium of modern PCs: L1 and L2 caches, internal

memory, multiple disks and remote hosts over a network.

The power of this memory organization is that it may be

able to oﬀer the expected access time of the fastest level

(i. e. cache) while keeping the average cost per memory

cell near the one of the cheapest level (i. e. disk), pro-

vided that data are properly cached and delivered to the

requiring algorithms. Neglecting questions pertaining to

the cost of memory references may even prevent the use

of algorithms on large sets of input data. Engineering re-

search is presently trying to improve the input/output

subsystem to reduce the impact of these issues, but it is

very well known [16] that the improvements achievable

by means of a proper arrangement of data and a prop-

erly structured algorithmic computation abundantly sur-

pass the best-expected technology advancements.

The Model of Computation

In order to reason about algorithms and data structures

operating on hierarchical memories, it is necessary to in-

troduce a model of computation that grasps the essence

of real situations so that algorithms that are good in the

model are also good in practice. The model considered

here is the external memory model [16], which received

much attention because of its simplicity and reasonable

accuracy. A computer is abstracted to consist of two mem-

ory levels: the internal memory of size M,andthe(un-

bounded) disk memory which operates by reading/writing

data in blocks of size B (called disk pages). The perfor-

mance of algorithms is then evaluated by counting: (a) the

number of disk accesses (I/Os), (b) the internal running

time (CPU time), and (c) the number of disk pages occu-

pied by the data structure or used by the algorithm as its

working space. This simple model suggests, correctly, that

a good external-memory algorithm should exploit both

spatial locality and temporal locality.Ofcourse,“I/O”and

“two-level view” refer to any two levels of the memory hi-

erarchy with their parameters M and B properly set.

Notation

Let S[1; n] be a string drawn from alphabet ˙, and con-

sider the notation: S

for the ith suﬃx of string S, lcp(˛; ˇ)

for the longest common preﬁx between the two strings ˛

and ˇ,andlca(u; v)forthelowest common ancestor be-

tween two nodes u and v in a tree.

The suﬃx tree of S[1; n], denoted hereafter by

,is

a tree that stores all suﬃxes of S# in a compact form,

where # 62 ˙ is a special character (see Fig. 1).

con-

sists of n leaves, numbered from 1 to n, and any root-to-

leaf path spells out a suﬃx of S#. The endmarker # guar-

antees that no suﬃx is the preﬁx of another suﬃx in S#.

Each internal node has at least two children and each edge

is labeled with a non empty substring of S.Notwoedges

out of a node can begin with the same character, and sib-

ling edges are ordered lexicographically according to that

character. Edge labels are encoded with pairs of integers –

say S[x; y] is represented by the pair hx; yi.Asaresult,

all (n

)substringsofS can be represented in O(n)opti-

mal space by

’s structure and edge encoding. Further-

more, the rightward scan of the suﬃx tree leaves gives the

ordered set of S’s suﬃxes, also known as the suﬃx array

of S [12]. Notice that the case of a large string collection

 = fS

; S

;:::;S

g reduces to the case of one long string

S = S

S

,where#

62 ˙ are special symbols.

Numerous algorithms are known that build the suﬃx

tree optimally in the RAM model (see [3] and references

therein). However, most of them exhibit a marked absence

of locality of references and thus elicit many I/Os when the

size of the indexed string is too large to be ﬁt into the in-

ternal memory of the computer. This is a serious problem

because the slow performance of these algorithms can pre-

vent the suﬃx tree being used even in medium-scale appli-

cations. This encyclopedia’s entry surveys algorithmic so-

lutions that deal eﬃciently with the construction of suﬃx

trees over large string collections by executing an optimal

number of I/Os. Since it is assumed that the edges leaving

anodein

are lexicographically sorted, sorting is an ob-

vious lower bound for building suﬃx trees (consider the

suﬃx tree of a permutation!). The presented algorithms

Suffix Tree Construction in Hierarchical Memory S 923

Suffix Tree Construction in Hierarchical Memory, Figure 1

ThesuffixtreeofS = ACACACCG on the left, and its compact edge-encoding on the right. The endmarker # is not shown. Node v

spells out the string ACAC. Each internal node stores the length of its associated string, and each leaf stores the starting position of

its corresponding suffix

DIVID E- AND-CONQUER ALGORITHM

(1) Construct the string S

[j]=rank of hS[2 j]; S[2j +1]i, and recursively compute T

(2) Derive from

the compacted trie T

of all suffixes of S beginning at odd positions.

(3) Derive from T

the compacted trie T

of all suffixes of S beginning at even positions.

(4) Merge T

and T

into the whole suffix tree T

, as follows:

(4.1) Overmerge

and T

into the tree T

(4.2) Partially unmerge T

to get T

Suffix Tree Construction in Hierarchical Memory, Figure 2

The algorithm that builds the suffix tree directly

have sorting as their bottleneck, thus establishing that the

complexity of sorting and suﬃx tree construction match.

Key Results

Designing a disk-eﬃcient approach to suﬃx-tree con-

struction has found eﬃcient solutions only in the last few

years [4]. The present section surveys two theoretical ap-

proaches which achieve the best (optimal!) I/O-bounds in

the worst case, the next section will discuss some practical

solutions.

The ﬁrst algorithm is based on a Divide-and-Conquer

approach that allows us to reduce the construction process

to external-memory sorting and few low-I/O primitives. It

builds the suﬃx tree

by executing four (macro)steps,

detailed in Fig. 2.Itisnotdiﬃculttoimplementthe

ﬁrst three steps in Sort(n)=O(

log

M/B

)I/Os[16].

The last (merging) step is the most diﬃcult one and its

I/O-complexity bounds the cost of the overall approach.

[3] proposes an elegant merge for

and T

:substep

(4.1) temporarily relaxes the requirement of getting

one shot, and thus it blindly (over)merges the paths of T

and T

by comparing edges only via their ﬁrst characters;

then substep (4.2) re-ﬁxes

by detecting and undoing

in an I/O-eﬃcient manner the (over)merged paths. Note

that the time and I/O-complexity of this algorithm follow

a nice recursive relation: T(n)=T(n/2) + O(Sort(n)).

Theorem 1 (Farach-Colton et al. 1999) Given an ar-

bitrary string S[1; n], its suﬃx tree can be constructed in

O(Sort(n)) I/Os, O(n log n) time and using O(n/B) disk

pages.

The second algorithm is deceptively simple, elegant and

I/O-optimal, and applies successfully to the construction

of other indexing data structures, like the String B-tree [5].

The key idea is to derive T

from the suﬃx array A

and from the lcp array, which stores the longest-com-

mon-preﬁx length of adjacent suﬃxes in A

.Itspseu-

docode is given in Fig. 3.NotethatStep(1)maydeploy

any external-memory algorithm for suﬃx array construc-

924 S Suffix Tree Construction in Hierarchical Memory

SU FFIXARRA Y-BASED ALGORITHM

(1) Construct the suffix array A

and the array lcp

of the string S.

(2) Initially set

as a single edge connecting the root to a leaf pointing to suffix A

[1].

(2) For i =2;:::;n:

(2.1) Create a new leaf `

that points to the suffix A

[i].

(2.2) Walk up from `

i1

until a node u

is met whose string-length x

is  lcp

[i].

(2.3) If x

= lcp

[i],leaf`

is attached to u

(2.4) If x

< lcp

[i],createnodeu

with string-length x

, attach it to u

and leaf `

to u

Suffix Tree Construction in Hierarchical Memory, Figure 3

The algorithm that builds the suffix tree passing through the suffix array

tion: Used here is the elegant and optimal Skew algorithm

of [9] which takes O(Sort(n)) I/Os. Step (2) takes a to-

tal of O(n/B) I/Os by using a stack that stores the nodes

on the current rightmost path of

in reversed order,

i. e. leaf `

is on top. Walking upward, splitting edges or

attaching nodes in T

boils down to popping/pushing

nodesfromthisstack.Asaresult,thetimeandI/O-

complexity of this algorithm follow the recursive relation:

T(n)=T(2n/3) + O(Sort(n)).

Theorem 2 (Kärkkäinen and Sanders 2003) Given an

arbitrary string S[1; n], its suﬃx tree can be constructed in

O(Sort(n)) I/Os, O(n log n) time and using O(n/B) disk

pages.

It is not evident which one of these two algorithms is better

in practice. The ﬁrst one exploits a recursion with param-

eter 1/2 but incurs a large space overhead because of the

management of the tree topology; the second one is more

space eﬃcient and easier to implement, but exploits a re-

cursion with parameter 2/3.

Applications

The reader is referred to [4]and[6] for a long list of appli-

cations of large suﬃx trees.

Open Problems

The recent theoretical and practical achievements mean

the idea that “suﬃx trees are not practical except when

thetextsizetohandleissosmallthatthesuﬃxtreeﬁts

in internal memory” is no longer the case [13]. Given

a suﬃx tree, it is known now (see e. g. [4,10]) how to

map it onto a disk-memory system in order to allow I/O-

eﬃcient traversals for subsequent pattern searches. A for-

tiori, suﬃx-tree storage and construction are challenging

problems that need further investigation.

Space optimization is closely related to time optimiza-

tion in a disk-memory system, so the design of succinct

suﬃx-tree implementations is a key issue in order to scale

to Gigabytes of data in reasonable time. This topic is an

active area of theoretical research with many fascinating

solutions (see e. g. [14]), which have not yet been fully ex-

plored in the practical setting.

It is theoretically challenging to design a suﬃx-tree

construction algorithm that takes optimal I/Os and space

proportional to the entropy of the indexed string. The

more compressible is the string, the lighter should be

the space requirement of this algorithm. Some results are

known [7,10,11], but both issues of compression and I/Os

have not yet been tackled jointly.

Experimental Results

The interest in building large suﬃx trees arose in the last

few years because of the recent advances in sequencing

technology, which have allowed the rapid accumulation

of DNA and protein data. Some recent papers [1,2,8,15]

proposed new practical algorithms that allow us to scale

to Gbps/hours. Surprisingly enough, these algorithms are

based on

disk-ineﬃcient schemes, but they properly se-

lect the insertion order of the suﬃxes and exploit care-

fully the internal memory as a buﬀer, so that their perfor-

mance does not suﬀers signiﬁcantly from the theoretical

I/O-bottleneck.

In [8] the authors propose an incremental algorithm,

called PrePar, which performs multiple passes over the

string S and constructs the suﬃx tree for a subrange of suf-

ﬁxes at each pass. For a user-deﬁned a parameter q,asuf-

ﬁx subrange is deﬁned as the set of suﬃxes preﬁxed by the

same q-long string. Suﬃx subranges induce subtrees of

which can thus be built independently, and evicted from

internal memory as they are completed. The experiments

reported in [8] successfully index 286 Mbps using 2 Gb in-

ternal memory.

In [2] the authors propose an improved version of

PrePar, called DynaCluster,thatdeploysadynamic

Suffix Tree Construction in RAM S 925

technique to identify suﬃx subranges. Unlike Prepar,

DynaCluster does not scan over and over the string S,

but it starts from the q-based subranges and then splits

them recursively in a DFS-manner if their size is larger

than a ﬁxed threshold  . Splitting is implemented by look-

ing at the next q characters of the suﬃxes in the subrange.

This clustering and lazy-DFS visit of

signiﬁcantly re-

duce the number of I/Os incurred by the frequent edge-

splitting operations that occur during the suﬃx tree con-

struction process; and allow it to cope eﬃciently with skew

data. As a result, DynaCluster constructs suﬃx trees

for 200Mbps with only 16 Mb internal memory.

More recently, [15] improved the space requirement

and the buﬀering eﬃciency, thus being able to construct

a suﬃx tree of 3 Gbps in 30 hours; whereas [1] improved

the I/O behavior of RAM-algorithms for online suﬃx-tree

construction, by devising a novel low-overhead buﬀering

policy.

Cross References

 Cache-Oblivious Sorting

 String Sorting

 Suﬃx Array Construction

 Suﬃx Tree Construction in RAM

 Text Indexing

Recommended Reading

1. Bedathur, S.J., Haritsa, J.R.: Engineering a fast online persistent

suffix tree construction., In: Proc. 20th International Confer-

ence on Data Engineering, pp. 720–731, Boston, USA (2004)

2. Cheung, C., Yu, J., Lu, H.: Constructing suffix tree for gigabyte

sequences with megabyte memory. IEEE Trans. Knowl. Data

Eng. 17, 90–105 (2005)

3. Farach-Colton, M., Ferragina, P., Muthukrishnan, S.: On the sort-

ing-complexity of suffix tree construction. J. ACM 47 987–1011

(2000)

4. Ferragina, P.: Handbook of Computational Molecular Biology.

In: Computer and Information Science Series, ch. 35 on “String

search in external memory: algorithms and data structures”.

Chapman & Hall/CRC, Florida (2005)

5. Ferragina, P., Grossi, R.: The string B-tree: A new data struc-

ture for string search in external memory and its applications.

J. ACM 46, 236–280 (1999)

6. Gusfield, D.: Algorithms on Strings, Trees and Sequences: Com-

puter Science and Computational Biology. Cambridge Univer-

sity Press, Cambridge (1997)

7. Hon, W., Sadakane, K., Sung, W.: Breaking a time-and-space

barrier in constructing full-text indices. In: IEEE Symposium on

Foundations of Computer Science (FOCS), 2003, pp. 251–260

8. Hunt, E., Atkinson, M., Irving, R.: Database indexing for large

DNA and protein sequence collections. Int. J. Very Large Data

Bases 11, 256–271 (2002)

9. Kärkkäinen, J., Sanders, P., Burkhardt, S.: Linear work suffix ar-

ray construction. J. ACM 53, 918–936 (2006)

10. Ko, P., Aluru, S.: Optimal self-adjusting trees for dynamic string

data in secondary storage. In: Symposium on String Processing

and Information Retrieval (SPIRE). LNCS, vol. 4726, pp. 184-194.

Springer, Berlin (2007)

11. Mäkinen, V., Navarro, G.: Dynamic Entropy-Compressed Se-

quences and Full-Text Indexes. In: Proc. 17th Symposium

on Combinatorial Pattern Matching (CPM). LNCS, vol. 4009,

pp. 307–318. Springer, Berlin (2006)

12. Manber,U.,Myers,G.:Suffixarrays:anewmethodforon-line

string searches. SIAM J. Comput. 22, 935–948 (1993)

13. Navarro,G.,Baeza-Yates,R.:Ahybridindexingmethodfor

approximate string matching. J. Discret. Algorithms 1, 21–49

(2000)

14. Navarro, G., Mäkinen, V.: Compressed full text indexes. ACM

Comput. Surv. 39(1) (2007)

15. Tata, S., Hankins, R.A., Patel, J.M.: Practical suffix tree construc-

tion. In: Proc. 13th International Conference on Very Large Data

Bases (VLDB), pp. 36–47, Toronto, Canada (2004)

16. Vitter, J.: External memory algorithms and data structures:

Dealing with MASSIVE DATA. ACM Comput. Surv. 33, 209–271

(2002)

Suffix Tree Construction in RAM

1997; Farach-Colton

JENS STOYE

Department of Technology,

University of Bielefeld, Bielefeld, Germany

Keywords and Synonyms

Full-text index construction

Problem Definition

Thesuﬃxtreeisperhapsthebest-knownandmost-

studied data structure for string indexing with applications

in many ﬁelds of sequence analysis. After its invention in

the early 1970s, several approaches for the eﬃcient con-

struction of the suﬃx tree of a string have been developed

for various models of computation. The most prominent

of those that construct the suﬃx tree in main memory are

summarized in this entry.

Notations

Given an alphabet ˙,atrie over ˙ is a rooted tree whose

edges are labeled with strings over ˙ such that no two la-

bels of edges leaving the same vertex start with the same

symbol. A trie is compacted if all its internal vertices, ex-

cept possibly the root, are branching. Given a ﬁnite string

S 2 ˙

,thesuﬃx tree of S, T(S), is the compacted trie over

˙ such that the concatenations of the edge labels along the

paths from the root to the leaves are the suﬃxes of S.An

example is given in Fig. 1.

926 S Suffix Tree Construction in RAM

SuffixTreeConstructioninRAM,Figure1

ThesuffixtreeforthestringS = MAMMAMIA. Dashed arrows de-

note suffix links that are employed by all efficient suffix tree con-

struction algorithms

The concatenation of the edge labels from the root to

a vertex v of T(S) is called the path-label of v, P(v). For ex-

ample, the path-label of the vertex indicated by the asterisk

in Fig. 1 is P()=MAM.

Constraints

The time complexity of constructing the suﬃx tree of

astringS of length n depends on the size of the underly-

ing alphabet ˙ . It may be constant, it may be the alphabet

of integers ˙ = f1; 2;:::;ng, or it may be an arbitrary ﬁ-

nite set whose elements can be compared in constant time.

Note that the latter case reduces to the previous one if one

maps the symbols of the alphabet to the set f1;:::;ng,

though at the additional cost of sorting ˙.

Problem 1 (suﬃx tree construction)

NPUT: A ﬁnite string S of length n over an alphabet ˙.

UTPUT:ThesuﬃxtreeT(S).

If one assumes that the outgoing edges at each vertex are

lexicographically sorted, which is usually the case, the suf-

ﬁx tree allows to retrieve the sorted order of S

scharacters

in linear time. Therefore, suﬃx tree construction inherits

the lower bounds from the problem complexity of sorting:

˝(n log n) in the general alphabet case, and ˝(n)forinte-

ger alphabets.

Key Results

Theorem 1 The suﬃx tree of a string of length n requires

(n log n) bits of space.

This is easy to see since the number of leaves of T(S)is

at most n, and so is the number of internal vertices that,

by deﬁnition, are all branching, as well as the number of

edges. In order to see that each edge label can be stored

in O(log n) bits of space, note that an edge label is always

asubstringofS. Hence it can be represented by a pair (`, r)

consisting of left pointer ` and right pointer r,ifthelabelis

S[`, r].

Note that this space bound is not optimal since there

are |˙|

diﬀerent strings and hence suﬃx trees, while

n log n bits would allow to represent n! diﬀerent entities.

Theorem 2 Suﬃx trees can be constructed in optimal time,

in particular:

1. For constant-size alphabet, the suﬃx tree T(S) of a string

S of length n can be constructed in O(n) time [11,

12,13]. For general alphabet, these algorithms require

O(n log n) time.

2. For integer alphabet, the suﬃx tree of S can be con-

structed in O(n) time [4,9].

Generally, there is a natural strategy to construct a suf-

ﬁx tree: Iteratively all suﬃxes are inserted into an initially

empty structure. Such a strategy will immediately lead to

a linear-time construction algorithm if each suﬃx can be

inserted in constant time. Finding the correct position

where to insert a suﬃx, however, is the main diﬃculty of

suﬃx tree construction.

The ﬁrst solution for this problem was given by Weiner

in his seminal 1973 paper [13]. His algorithm inserts the

suﬃxes from shortest to longest, and the insertion point

is found in amortized constant time for constant-size al-

phabet, using rather a complicated amount of additional

data structures. A simpliﬁed version of the algorithm was

presented by Chen and Seiferas [3]. They give a cleaner

presentation of the three types of links that are required in

order to ﬁnd the insertion points of suﬃxes eﬃciently, and

their complexity proof is easier to follow. Since the suﬃx

tree is constructed while reading the text from right to left,

these two algorithms are sometimescalled anti-online con-

structions.

A diﬀerent algorithm was given 1976 by Mc-

Creight [11]. In this algorithm the suﬃxes are inserted

into the growing tree from longest to shortest. This sim-

pliﬁes the update procedure, and the additional data struc-

ture is limited to just one type of link: an internal vertex

v with path label P(v)=aw for some symbol a 2 ˙ and

string w 2 ˙



has a suﬃx link to the vertex u with path la-

bel P(u)=w.InFig.1, suﬃx links are shown as dashed

arrows. They often connect vertices above the insertion

points of consecutively inserted suﬃxes, like the vertex

with path-label “M” and the root, when inserting suﬃxes

Suffix Tree Construction in RAM S 927

“MAMIA” and “AMIA” in the example of Fig. 1.This

property allows to reach the next insertion point without

having to search for it from the root of the tree, thus en-

suring amortized constant time per suﬃx insertion. Note

that since McCreight’s algorithm treats the suﬃxes from

longest to shortest and the intermediate structures are not

suﬃx trees, the algorithm is not an online algorithm.

Another linear-time algorithm for constant size alpha-

bet is the online construction by Ukkonen [12]. It reads

the text from left to right and updates the suﬃx tree in

amortized constant time per added symbol. Again, the al-

gorithm uses suﬃx links in order to quickly ﬁnd the inser-

tion points for the suﬃxes to be inserted. Moreover, since

during a single update the edge labels of all leaf-edges need

to be extended by the new symbol, it requires a trick to ex-

tend all these labels in constant time: all the right pointers

of the leaf edges refer to the same end of string value, which

is just incremented.

An even stronger concept than online construction is

real-time construction, where the worst-case (instead of

amortized) time per symbol is considered. Amir et al. [1]

present for general alphabet a suﬃx tree construction al-

gorithm that requires O(log n) worst-case update time per

every single input symbol when the text is read from right

to left, and thus requires overall O(n log n)time,likethe

other algorithms for general alphabet mentioned so far.

They achieve this goal using a binary search tree on the

suﬃxes of the text, enhanced by additional pointers repre-

senting the lexicographic and the textual order of the suf-

ﬁxes, called Balanced Indexing Structure.Thistreecanbe

constructed in O(log n) worst-case time per added sym-

bol and allows to maintain the suﬃx tree in the same time

bound.

The ﬁrst linear-time suﬃx tree construction algorithm

for integer alphabets was given by Farach–Colton [4]. It

uses the so-called odd-even technique that proceeds in

three steps:

1. Recursively compute the compacted trie of all suﬃxes

of S beginning at odd positions, called the odd tree T

2. From T

compute the even tree T

,thecompactedtrie

of the suﬃxes beginning at even positions in S.

3. Merge T

and T

into the whole suﬃx tree T(S).

Thebasicideaoftheﬁrststepistoencodepairsof

characters as single characters. Since at most n/2 diﬀerent

such characters can occur, these can be radix-sorted and

range-reduced to an alphabet of size n/2. Thus, the string

S of length n over the integer alphabet ˙ = f1;:::;ng is

translated in O(n) time into a string S

of length n/2 over

the integer alphabet ˙

= f1;:::;n/2g. Applying the algo-

rithm recursively to this string yields the suﬃx tree of S

After translating the edge labels from substrings of S

back

to substrings of S, some vertices may exist with outgoing

edges whose labels start with the same symbol, because two

distinct symbols from ˙

may be pairs with the same ﬁrst

symbol from ˙ . In such cases, by local modiﬁcations of

edge labels or adding additional vertices the trie property

can be regained and the desired tree T

is obtained.

In the second step, the odd tree T

from the ﬁrst step

is used to generate the lexicographically sorted list (lex-

ordering for short) of the suﬃxes starting at odd positions.

Radix-sorting these with the characters at the preceding

even positions as keys yields a lex-ordering of the even

suﬃxes in linear time. Together with the longest common

preﬁxes of consecutive positions that can be computed in

linear time from T

using constant-time lowest common

ancestor queries and the identity

lcp(l

; l



lcp(l

2i+1

; l

2j+1

)+1 ifS[2i]=S[2j]

0otherwise

this ordering allows to reconstruct the even tree T

in lin-

ear time.

In the third step, the two tries T

and T

are merged

into the suﬃx tree T(S).Conceptually,thisisastraight-

forward procedure: the two tries are traversed in parallel,

and every part that is present in one or both of the two

trees, is inserted in the common structure. However, this

procedure is simple only if edges are traversed character

by character such that common and diﬀering parts can be

observed directly. Such a traversal would, however, require

O(n

) time in the worst case, impeding the desired overall

linear running time. Therefore, Farach-Colton suggests to

use an oracle that tells, for an edge of T

and an edge of

the length of their common preﬁx. However, the sug-

gested oracle may overestimate this length, and that is why

sometimes the tree generated must be corrected, called un-

merging. The full details of the oracle and the unmerging

procedure can be found in [4].

Overall, if T(n) is the time it takes to build the suf-

ﬁx tree of a string S 2f1;:::;ng

, the ﬁrst step takes

T(n/2) + O(n) time and the second and third step take

O(n) time, thus the whole procedure takes O(n) overall

time on the RAM model.

Another linear-time construction of suﬃx trees for in-

teger alphabets can be achieved via linear-time construc-

tion of suﬃx arrays together with longest common preﬁx

tabulation, as described by Kärkkäinen and Sanders in [9].

In some applications the so-called generalized suﬃx

tree of several strings is used, a dictionary obtained by con-

structing the suﬃx tree of the concatenation of the con-

tained strings. An important question that arises in this

context is that of dynamically updating the tree upon in-

sertion and deletion of strings from the dictionary. More