Incomputer science, asuffix tree (also calledPAT tree or, in an earlier form,position tree) is a compressedtrie containing all thesuffixes of the given text as their keys and positions in the text as their values. Suffix trees allow particularly fast implementations of many important string operations.

The construction of such a tree for the string${\displaystyle S}$ takes time and space linear in the length of${\displaystyle S}$. Once constructed, several operations can be performed quickly, such as locating asubstring in${\displaystyle S}$, locating a substring if a certain number of mistakes are allowed, and locating matches for aregular expression pattern. Suffix trees also provided one of the first linear-time solutions for thelongest common substring problem.^[2] These speedups come at a cost: storing a string's suffix tree typically requires significantly more space than storing the string itself.

The concept was first introduced byWeiner (1973).Rather than the suffix${\displaystyle S[i..n]}$, Weiner stored in his trie^[3] theprefix identifier for each position, that is, the shortest string starting at${\displaystyle i}$ and occurring only once in${\displaystyle S}$. HisAlgorithm D takes an uncompressed^[4] trie for${\displaystyle S[k+\mathrm{1..}n]}$ and extends it into a trie for${\displaystyle S[k..n]}$. This way, starting from the trivial trie for${\displaystyle S[n..n]}$, a trie for${\displaystyle S[\mathrm{1..}n]}$ can be built by${\displaystyle n-1}$ successive calls to Algorithm D; however, the overall run time is${\displaystyle O(n^2)}$. Weiner'sAlgorithm B maintains several auxiliary data structures, to achieve an overall run time linear in the size of the constructed trie. The latter can still be${\displaystyle O(n^2)}$ nodes, e.g. for${\displaystyle S=a^n{b}^n{a}^n{b}^n\mathrm{\$}.}$ Weiner'sAlgorithm C finally uses compressed tries to achieve linear overall storage size and run time.^[5]Donald Knuth subsequently characterized the latter as "Algorithm of the Year 1973" according to his studentVaughan Pratt.^{[original research?][6]}The text bookAho, Hopcroft & Ullman (1974, Sect.9.5) reproduced Weiner's results in a simplified and more elegant form, introducing the termposition tree.

McCreight (1976) was the first to build a (compressed) trie of all suffixes of${\displaystyle S}$. Although the suffix starting at${\displaystyle i}$ is usually longer than the prefix identifier, their path representations in a compressed trie do not differ in size. On the other hand, McCreight could dispense with most of Weiner's auxiliary data structures; only suffix links remained.

Ukkonen (1995) further simplified the construction.^[6] He provided the first online-construction of suffix trees, now known asUkkonen's algorithm, with running time that matched the then fastest algorithms.These algorithms are all linear-time for a constant-size alphabet, and have worst-case running time of${\displaystyle O(n\log n)}$ in general.

Farach (1997) gave the first suffix tree construction algorithm that is optimal for all alphabets. In particular, this is the first linear-time algorithm for strings drawn from an alphabet of integers in a polynomial range. Farach's algorithm has become the basis for new algorithms for constructing both suffix trees andsuffix arrays, for example, in external memory, compressed, succinct, etc.

The suffix tree for the string${\displaystyle S}$ of length${\displaystyle n}$ is defined as a tree such that:^[7]

1. The tree has exactly n leaves numbered from${\displaystyle 1}$ to${\displaystyle n}$.
2. Except for the root, everyinternal node has at least two children.
3. Each edge is labelled with a non-empty substring of${\displaystyle S}$.
4. No two edges starting out of a node can have string-labels beginning with the same character.
5. The string obtained by concatenating all the string-labels found on the path from the root to leaf${\displaystyle i}$ spells out suffix${\displaystyle S[i..n]}$, for${\displaystyle i}$ from${\displaystyle 1}$ to${\displaystyle n}$.

If a suffix of${\displaystyle S}$ is also the prefix of another suffix, such a tree does not exist for the string. For example, in the stringabcbc, the suffixbc is also a prefix of the suffixbcbc. In such a case, the path spelling outbc will not end in a leaf, violating the fifth rule. To fix this problem,${\displaystyle S}$ is padded with a terminal symbol not seen in the string (usually denoted$). This ensures that no suffix is a prefix of another, and that there will be${\displaystyle n}$ leaf nodes, one for each of the${\displaystyle n}$ suffixes of${\displaystyle S}$.^[8] Since all internal non-root nodes are branching, there can be at most${\displaystyle n-1}$ such nodes, and${\displaystyle n+(n-1)+1=2n}$ nodes in total (${\displaystyle n}$ leaves,${\displaystyle n-1}$ internal non-root nodes, 1 root).

Suffix links are a key feature for older linear-time construction algorithms, although most newer algorithms, which are based onFarach's algorithm, dispense with suffix links. In a complete suffix tree, all internal non-root nodes have a suffix link to another internal node. If the path from the root to a node spells the string${\displaystyle \chi \alpha }$, where${\displaystyle \chi }$ is a single character and${\displaystyle \alpha }$ is a string (possibly empty), it has a suffix link to the internal node representing${\displaystyle \alpha }$. See for example the suffix link from the node forANA to the node forNA in the figure above. Suffix links are also used in some algorithms running on the tree.

Ageneralized suffix tree is a suffix tree made for a set of strings instead of a single string. It represents all suffixes from this set of strings. Each string must be terminated by a different termination symbol.

A suffix tree for a string${\displaystyle S}$ of length${\displaystyle n}$ can be built in${\displaystyle \mathrm{\Theta }(n)}$ time, if the letters come from an alphabet of integers in a polynomial range (in particular, this is true for constant-sized alphabets).^[9]For larger alphabets, the running time is dominated by firstsorting the letters to bring them into a range of size${\displaystyle O(n)}$; in general, this takes${\displaystyle O(n\log n)}$ time.The costs below are given under the assumption that the alphabet is constant.

Assume that a suffix tree has been built for the string${\displaystyle S}$ of length${\displaystyle n}$, or that ageneralised suffix tree has been built for the set of strings${\displaystyle D=\{S_1,S_2,\dots ,S_K\}}$ of total length${\displaystyle n=n_1+n_2+\cdots +n_K}$.You can:

• Search for strings:
  • Check if a string${\displaystyle P}$ of length${\displaystyle m}$ is a substring in${\displaystyle O(m)}$ time.^[10]
  • Find the first occurrence of the patterns${\displaystyle P_1,\dots ,P_q}$ of total length${\displaystyle m}$ as substrings in${\displaystyle O(m)}$ time.
  • Find all${\displaystyle z}$ occurrences of the patterns${\displaystyle P_1,\dots ,P_q}$ of total length${\displaystyle m}$ as substrings in${\displaystyle O(m+z)}$ time.^[11]
  • Search for aregular expressionP in time expectedsublinear in${\displaystyle n}$.^[12]
  • Find for each suffix of a pattern${\displaystyle P}$, the length of the longest match between a prefix of${\displaystyle P[i\dots m]}$ and a substring in${\displaystyle D}$ in${\displaystyle \mathrm{\Theta }(m)}$ time.^[13] This is termed thematching statistics for${\displaystyle P}$.
• Find properties of the strings:
  • Find thelongest common substrings of the string${\displaystyle S_i}$ and${\displaystyle S_j}$ in${\displaystyle \mathrm{\Theta }(n_i+n_j)}$ time.^[14]
  • Find allmaximal pairs, maximal repeats or supermaximal repeats in${\displaystyle \mathrm{\Theta }(n+z)}$ time.^[15]
  • Find theLempel–Ziv decomposition in${\displaystyle \mathrm{\Theta }(n)}$ time.^[16]
  • Find thelongest repeated substrings in${\displaystyle \mathrm{\Theta }(n)}$ time.^[17]
  • Find the most frequently occurring substrings of a minimum length in${\displaystyle \mathrm{\Theta }(n)}$ time.^{[citation needed]}
  • Find the shortest strings from${\displaystyle \mathrm{\Sigma }}$ that do not occur in${\displaystyle D}$, in${\displaystyle O(n+z)}$ time, if there are${\displaystyle z}$ such strings.^{[citation needed]}
  • Find the shortest substrings occurring only once in${\displaystyle \mathrm{\Theta }(n)}$ time.^{[citation needed]}
  • Find, for each${\displaystyle i}$, the shortest substrings of${\displaystyle S_i}$ not occurring elsewhere in${\displaystyle D}$ in${\displaystyle \mathrm{\Theta }(n)}$ time.^{[citation needed]}

The suffix tree can be prepared for constant timelowest common ancestor retrieval between nodes in${\displaystyle \mathrm{\Theta }(n)}$ time.^[18] One can then also:

• Find the longest common prefix between the suffixes${\displaystyle S_i[p..n_i]}$ and${\displaystyle S_j[q..n_j]}$ in${\displaystyle \mathrm{\Theta }(1)}$.^[19]
• Search for a patternP of lengthm with at mostk mismatches in${\displaystyle O(kn+z)}$ time, wherez is the number of hits.^[20]
• Find all${\displaystyle z}$ maximalpalindromes in${\displaystyle \mathrm{\Theta }(n)}$,^[21] or${\displaystyle \mathrm{\Theta }(gn)}$ time if gaps of length${\displaystyle g}$ are allowed, or${\displaystyle \mathrm{\Theta }(kn)}$ if${\displaystyle k}$ mismatches are allowed.^[22]
• Find all${\displaystyle z}$tandem repeats in${\displaystyle O(n\log n+z)}$, andk-mismatch tandem repeats in${\displaystyle O(kn\log (n/k)+z)}$.^[23]
• Find thelongest common substrings to at least${\displaystyle k}$ strings in${\displaystyle D}$ for${\displaystyle k=2,\dots ,K}$ in${\displaystyle \mathrm{\Theta }(n)}$ time.^[24]
• Find thelongest palindromic substring of a given string (using the generalized suffix tree of the string and its reverse) in linear time.^[25]

Suffix trees can be used to solve a large number of string problems that occur in text-editing, free-text search,computational biology and other application areas.^[26] Primary applications include:^[26]

• String search, inO(m) complexity, wherem is the length of the sub-string (but with initialO(n) time required to build the suffix tree for the string)
• Finding the longest repeated substring
• Finding the longest common substring
• Finding the longestpalindrome in a string

Suffix trees are often used inbioinformatics applications, searching for patterns inDNA orprotein sequences (which can be viewed as long strings of characters). The ability to search efficiently with mismatches might be considered their greatest strength. Suffix trees are also used indata compression; they can be used to find repeated data, and can be used for the sorting stage of theBurrows–Wheeler transform. Variants of theLZW compression schemes use suffix trees (LZSS). A suffix tree is also used insuffix tree clustering, adata clustering algorithm used in some search engines.^[27]

If each node and edge can be represented in${\displaystyle \mathrm{\Theta }(1)}$ space, the entire tree can be represented in${\displaystyle \mathrm{\Theta }(n)}$ space. The total length of all the strings on all of the edges in the tree is${\displaystyle O(n^2)}$, but each edge can be stored as the position and length of a substring ofS, giving a total space usage of${\displaystyle \mathrm{\Theta }(n)}$ computer words. The worst-case space usage of a suffix tree is seen with afibonacci word, giving the full${\displaystyle 2n}$ nodes.

An important choice when making a suffix tree implementation is the parent-child relationships between nodes. The most common is usinglinked lists calledsibling lists. Each node has a pointer to its first child, and to the next node in the child list it is a part of. Other implementations with efficient running time properties usehash maps, sorted or unsortedarrays (witharray doubling), orbalanced search trees. We are interested in:

• The cost of finding the child on a given character.
• The cost of inserting a child.
• The cost of enlisting all children of a node (divided by the number of children in the table below).

Letσ be the size of the alphabet. Then you have the following costs:^{[citation needed]}

The insertion cost is amortised, and that the costs for hashing are given for perfect hashing.

The large amount of information in each edge and node makes the suffix tree very expensive, consuming about 10 to 20 times the memory size of the source text in good implementations. Thesuffix array reduces this requirement to a factor of 8 (for array includingLCP values built within 32-bit address space and 8-bit characters.) This factor depends on the properties and may reach 2 with usage of 4-byte wide characters (needed to contain any symbol in someUNIX-like systems, seewchar_t) on 32-bit systems.^{[citation needed]} Researchers have continued to find smaller indexing structures.

Various parallel algorithms to speed up suffix tree construction have been proposed.^{[28][29][30][31][32]}Recently, a practical parallel algorithm for suffix tree construction with${\displaystyle O(n)}$work (sequential time) and${\displaystyle O({\log }^{2}n)}$span has been developed. The algorithm achieves good parallel scalability on shared-memory multicore machines and can index thehuman genome – approximately 3GB – in under 3 minutes using a 40-core machine.^[33]

Though linear, the memory usage of a suffix tree is significantly higherthan the actual size of the sequence collection. For a large text,construction may require external memory approaches.

There are theoretical results for constructing suffix trees in externalmemory.The algorithm byFarach-Colton, Ferragina & Muthukrishnan (2000)is theoretically optimal, with an I/O complexity equal to that of sorting.However the overall intricacy of this algorithm has prevented, so far, itspractical implementation.^[34]

On the other hand, there have been practical works for constructingdisk-based suffix treeswhich scale to (few) GB/hours.The state of the art methods are TDD,^[35]TRELLIS,^[36]DiGeST,^[37]andB²ST.^[38]

TDD and TRELLIS scale up to the entire human genome resulting in a disk-based suffix tree of a size in the tens of gigabytes.^[35][36] However, these methods cannot handle efficiently collections of sequences exceeding 3 GB.^[37] DiGeST performs significantly better and is able to handle collections of sequences in the order of 6 GB in about 6 hours.^[37]

All these methods can efficiently build suffix trees for the case when thetree does not fit in main memory,but the input does.The most recent method, B²ST,^[38] scales to handleinputs that do not fit in main memory. ERA is a recent parallel suffix tree construction method that is significantly faster. ERA can index the entire human genome in 19 minutes on an 8-core desktop computer with 16 GB RAM. On a simple Linux cluster with 16 nodes (4 GB RAM per node), ERA can index the entire human genome in less than 9 minutes.^[39]

• Suffix automaton

• Aho, Alfred V.;Hopcroft, John E.;Ullman, Jeffrey D. (1974),The Design and Analysis of Computer Algorithms, Reading/MA: Addison-Wesley,Bibcode:1974daca.book.....A,ISBN 0-201-00029-6.
• Apostolico, A.; Iliopoulos, C.; Landau, G. M.; Schieber, B.; Vishkin, U. (1988),"Parallel construction of a suffix tree with applications",Algorithmica,3 (1–4):347–365,doi:10.1007/bf01762122,S2CID 5024136.
• Baeza-Yates, Ricardo A.;Gonnet, Gaston H. (1996), "Fast text searching for regular expressions or automaton searching on tries",Journal of the ACM,43 (6):915–936,doi:10.1145/235809.235810,S2CID 1420298.
• Barsky, Marina; Stege, Ulrike; Thomo, Alex; Upton, Chris (2008), "A new method for indexing genomes using on-disk suffix trees",CIKM '08: Proceedings of the 17th ACM Conference on Information and Knowledge Management(PDF), New York, NY, USA: ACM, pp. 649–658.
• Barsky, Marina; Stege, Ulrike; Thomo, Alex; Upton, Chris (2009), "Suffix trees for very large genomic sequences",CIKM '09: Proceedings of the 18th ACM Conference on Information and Knowledge Management(PDF), New York, NY, USA: ACM.
• Farach, Martin (1997),"Optimal Suffix Tree Construction with Large Alphabets"(PDF),38th IEEE Symposium on Foundations of Computer Science (FOCS '97), pp. 137–143.
• Farach, Martin;Muthukrishnan, S. (1996), "Optimal Logarithmic Time Randomized Suffix Tree Construction",International Colloquium on Automata Languages and Programming(PDF).
• Farach-Colton, Martin; Ferragina, Paolo;Muthukrishnan, S. (2000), "On the sorting-complexity of suffix tree construction.",Journal of the ACM,47 (6):987–1011,doi:10.1145/355541.355547,S2CID 8164822.
• Giegerich, R.; Kurtz, S. (1997),"From Ukkonen to McCreight and Weiner: A Unifying View of Linear-Time Suffix Tree Construction"(PDF),Algorithmica,19 (3):331–353,doi:10.1007/PL00009177,S2CID 18039097, archived fromthe original(PDF) on 2016-03-03, retrieved2012-07-13.
• Gusfield, Dan (1997),Algorithms on Strings, Trees and Sequences: Computer Science and Computational Biology, Cambridge University Press,ISBN 0-521-58519-8.
• Hariharan, Ramesh (1994), "Optimal Parallel Suffix Tree Construction",ACM Symposium on Theory of Computing(PDF).
• Iliopoulos, Costas; Rytter, Wojciech (2004), "On Parallel Transformations of Suffix Arrays into Suffix Trees",15th Australasian Workshop on Combinatorial Algorithms,CiteSeerX 10.1.1.62.6715.
• Mansour, Essam; Allam, Amin; Skiadopoulos, Spiros; Kalnis, Panos (2011),"ERA: Efficient Serial and Parallel Suffix Tree Construction for Very Long Strings"(PDF),Proceedings of the VLDB Endowment,5 (1):49–60,arXiv:1109.6884,Bibcode:2011arXiv1109.6884M,doi:10.14778/2047485.2047490,S2CID 7582116.
• McCreight, Edward M. (1976), "A Space-Economical Suffix Tree Construction Algorithm",Journal of the ACM,23 (2):262–272,CiteSeerX 10.1.1.130.8022,doi:10.1145/321941.321946,S2CID 9250303.
• Phoophakdee, Benjarath; Zaki, Mohammed J. (2007), "Genome-scale disk-based suffix tree indexing",SIGMOD '07: Proceedings of the ACM SIGMOD International Conference on Management of Data, New York, NY, USA: ACM, pp. 833–844,CiteSeerX 10.1.1.81.6031.
• Sahinalp, Cenk; Vishkin, Uzi (1994), "Symmetry breaking for suffix tree construction",ACM Symposium on Theory of Computing, pp. 300–309,doi:10.1145/195058.195164,ISBN 0-89791-663-8,S2CID 5985171
• Smyth, William (2003),Computing Patterns in Strings,Addison-Wesley.
• Shun, Julian; Blelloch, Guy E. (2014), "A Simple Parallel Cartesian Tree Algorithm and its Application to Parallel Suffix Tree Construction",ACM Transactions on Parallel Computing,1:1–20,doi:10.1145/2661653,S2CID 1912378.
• Tata, Sandeep; Hankins, Richard A.; Patel, Jignesh M. (2003), "Practical Suffix Tree Construction",VLDB '03: Proceedings of the 30th International Conference on Very Large Data Bases(PDF), Morgan Kaufmann, pp. 36–47.
• Ukkonen, E. (1995),"On-line construction of suffix trees"(PDF),Algorithmica,14 (3):249–260,doi:10.1007/BF01206331,S2CID 6027556.
• Weiner, P. (1973),"Linear pattern matching algorithms"(PDF),14th Annual IEEE Symposium on Switching and Automata Theory, pp. 1–11,doi:10.1109/SWAT.1973.13, archived fromthe original(PDF) on 2016-03-03, retrieved2015-04-16.
• Zamir, Oren;Etzioni, Oren (1998), "Web document clustering: a feasibility demonstration",SIGIR '98: Proceedings of the 21st annual international ACM SIGIR conference on Research and development in information retrieval, New York, NY, USA: ACM, pp. 46–54,CiteSeerX 10.1.1.36.4719.

• Suffix Trees bySartaj Sahni
• NIST's Dictionary of Algorithms and Data Structures: Suffix Tree
• Universal Data Compression Based on the Burrows-Wheeler Transformation: Theory and Practice, application of suffix trees in the BWT
• Theory and Practice of Succinct Data Structures, C++ implementation of a compressed suffix tree
• Ukkonen's Suffix Tree Implementation in CPart 1Part 2Part 3Part 4Part 5Part 6
• Online Demo: Ukkonen's Suffix Tree Visualization

• Trees (data structures)
• Substring indices
• String data structures
• Computer science suffixes

• Harv and Sfn no-target errors
• Articles with short description
• Short description is different from Wikidata
• All articles that may contain original research
• Articles that may contain original research from February 2020
• All articles with unsourced statements
• Articles with unsourced statements from August 2025
• Articles with unsourced statements from October 2024