|
|
| Line 1: |
Line 1: |
| [[Image:Suffix tree BANANA.svg|thumb|250px|right|Suffix tree for the text <code>BANANA</code>. Each substring is terminated with special character <code>$</code>. The six paths from the root to a leaf (shown as boxes) correspond to the six suffixes <code>A$</code>, <code>NA$</code>, <code>ANA$</code>, <code>NANA$</code>, <code>ANANA$</code> and <code>BANANA$</code>. The numbers in the leaves give the start position of the corresponding suffix. Suffix links, drawn dashed, are used during construction.]]
| | To your abode the Clash of Clans hack tool; there could be also hack tools for the other games. People can check out all of the hacks and obtain those which they need. It is sure that they will have lost of fun once they take the hack tool saved.<br><br>Some of the upsides of video video game titles can [http://Www.Tumblr.com/tagged/include include] fun, entertainment and even education. The downsides range at the hands of addictive game play to younger individuals seeing and hearing things they are not old enough when considering. In the event you loved this article and you would want to receive more info concerning [http://prometeu.net clash of clans hack tool no survey no password] generously visit our web site. With luck, their ideas presented within the following article can help your entire family manage video games well within your home as for everyone's benefit.<br><br>Temperance is essential in a large amount of things, and enjoying clash of clans cheats is no special. [https://www.google.com/search?hl=en&gl=us&tbm=nws&q=Playing&btnI=lucky Playing] for hours on finish is not really good-for-you, bodily or on an emotional level. There are some games out so there which know this and can include measures to remind one to take rests. Go ahead and take initiative yourself, although! Place an alarm and also that don't play for over an hour right.<br><br>Explore the evaluations and see the trailers before buying another video game. Allow it to become one thing you are looking at before you get in which. These video games aren't low-cost, and also you doesn't just get nearly as abundant cash whenever you companies inside a employed video gaming which you have solitary utilized several times.<br><br>Evaporate true, you've landed in the correct spot! Truly, we have produced after lengthy hrs of research, perform and screening, an alternative for thr Clash related to Clans Cheat totally invisible and operates perfectly. And due to your energy of our teams, this never-ending hrs of satisfaction in your iPhone, ipad device or iPod Touch performing Clash of Clans our own cheat code Clash of Clans produced especially for you personally!<br><br>Anyone have are the proud holder of an ANY lightweight device that runs directly on iOS or android as a a touchscreen tablet workstation or a smart phone, then you definitely would need to have already been mindful of the revolution taking place right now in the world of mobile personal game "The Clash Having to do with Clans", and you will probably be in demand of conflict of families unfastened jewels compromise because a bit more gems, elixir and sterling silver are needed seriously toward acquire every battle.<br><br>Evidently individuals who produced this Crack Clash of Loved ones are true fans related with the sport themselves, also this is exactly the thing that ensures the potency created by our alternative, because we will needed to do the idea ourselves. |
| | |
| In [[computer science]], a '''suffix tree''' (also called '''PAT tree''' or, in an earlier form, '''position tree''') is a compressed [[trie]] containing all the [[suffix (computer science)|suffixes]] of the given text as their keys and positions in the text as their values. Suffix tree allows a particularly fast implementation of many important string operations.
| |
| | |
| The construction of such a tree for the string <math>S</math> takes time and space linear in the length of <math>S</math>. Once constructed, several operations can be performed quickly, for instance locating a [[substring]] in <math>S</math>, locating a substring if a certain number of mistakes are allowed, locating matches for a [[regular expression]] pattern etc. Suffix trees also provided one of the first linear-time solutions for the [[longest common substring problem]]. These speedups come at a cost: storing a string's suffix tree typically requires significantly more space than storing the string itself.
| |
| | |
| ==History==
| |
| The concept was first introduced by {{harvtxt|Weiner|1973}}, which [[Donald Knuth]] subsequently characterized as "Algorithm of the Year 1973". The construction was greatly simplified by {{harvtxt|McCreight|1976}}
| |
| , and also by {{harvtxt|Ukkonen|1995}}.{{sfnp|Giegerich|Kurtz|1997}} Ukkonen provided the first online-construction of suffix trees, now known as [[Ukkonen'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 <math>O(n\log n)</math> in general.
| |
| | |
| {{harvtxt|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 and [[suffix array]]s, for example, in external memory, compressed, succinct, etc.
| |
| | |
| ==Definition==
| |
| The suffix tree for the string <math>S</math> of length <math>n</math> is defined as a tree such that:<ref>http://www.cs.uoi.gr/~kblekas/courses/bioinformatics/Suffix_Trees1.pdf</ref><!-- ref>{{harvtxt|Gusfield|1999}}, p.90.</ref -->
| |
| * The tree has exactly n leaves numbered from 1 to n.
| |
| * Except for the root, every internal node has at least two children.
| |
| * Each edge is labeled with a non-empty substring of S.
| |
| * No two edges starting out of a node can have string-labels beginning with the same character.
| |
| * The string obtained by concatenating all the string-labels found on the path from the root to leaf i spells out suffix S[i..n], for i from 1 to n.
| |
| | |
| Since such a tree does not exist for all strings, <math>S</math> is padded with a terminal symbol not seen in the string (usually denoted <code>$</code>). This ensures that no suffix is a prefix of another, and that there will be <math>n</math> leaf nodes, one for each of the <math>n</math> suffixes of <math>S</math>. Since all internal non-root nodes are branching, there can be at most ''n'' − 1 such nodes, and ''n'' + (''n'' − 1) + 1 = 2''n'' nodes in total (''n'' leaves, ''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 on [[Farach'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 <math>\chi\alpha</math>, where <math>\chi</math> is a single character and <math>\alpha</math> is a string (possibly empty), it has a suffix link to the internal node representing <math>\alpha</math>. See for example the suffix link from the node for <code>ANA</code> to the node for <code>NA</code> in the figure above. Suffix links are also used in some algorithms running on the tree.
| |
| | |
| ==Generalized suffix tree==
| |
| A [[generalized suffix tree]] is a suffix tree made for a set of words instead of only for a single word. It represents all suffixes from this set of words. Each word must be terminated by a different termination symbol or word.
| |
| | |
| ==Functionality==
| |
| | |
| A suffix tree for a string <math>S</math> of length <math>n</math> can be built in <math>\Theta(n)</math> time, if the letters come from an alphabet of integers in a polynomial range (in particular, this is true for constant-sized alphabets).{{sfnp|Farach|1997}}
| |
| For larger alphabets, the running time is dominated by first [[Sorting algorithm|sorting]] the letters to bring them into a range of size <math>O(n)</math>; in general, this takes <math>O(n\log n)</math> 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 <math>S</math> of length <math>n</math>, or that a [[generalised suffix tree]] has been built for the set of strings <math>D=\{S_1,S_2,\dots,S_K\}</math> of total length <math>n=|n_1|+|n_2|+\cdots+|n_K|</math>.
| |
| You can:
| |
| | |
| * Search for strings:
| |
| ** Check if a string <math>P</math> of length <math>m</math> is a substring in <math>O(m)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.92.</ref>
| |
| ** Find the first occurrence of the patterns <math>P_1,\dots,P_q</math> of total length <math>m</math> as substrings in <math>O(m)</math> time.
| |
| ** Find all <math>z</math> occurrences of the patterns <math>P_1,\dots,P_q</math> of total length <math>m</math> as substrings in <math>O(m + z)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.123.</ref>
| |
| <!-- ** Search for a pattern <math>P</math> of length <math>m</math> with at most <math>k</math> mismatches in <math>O(m \sum_{r=0}^k * {m \choose r} (|\Sigma| - 1)^k + z)</math> time.-->
| |
| ** Search for a [[regular expression]] ''P'' in time expected [[Sublinear time algorithm|sublinear]] in <math>n</math>.{{sfnp|Baeza-Yates|Gonnet|1996}}
| |
| ** Find for each suffix of a pattern <math>P</math>, the length of the longest match between a prefix of <math>P[i\dots m]</math> and a substring in <math>D</math> in <math>\Theta(m)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.132.</ref> This is termed the '''matching statistics''' for <math>P</math>.
| |
| * Find properties of the strings:
| |
| ** Find the [[longest common substring problem|longest common substrings]] of the string <math>S_i</math> and <math>S_j</math> in <math>\Theta(n_i + n_j)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.125.</ref>
| |
| ** Find all [[maximal pair]]s, maximal repeats or supermaximal repeats in <math>\Theta(n + z)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.144.</ref>
| |
| ** Find the [[Lempel–Ziv]] decomposition in <math>\Theta(n)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.166.</ref>
| |
| ** Find the [[longest repeated substring problem|longest repeated substrings]] in <math>\Theta(n)</math> time.
| |
| ** Find the most frequently occurring substrings of a minimum length in <math>\Theta(n)</math> time.
| |
| ** Find the shortest strings from <math>\Sigma</math> that do not occur in <math>D</math>, in <math>O(n + z)</math> time, if there are <math>z</math> such strings.
| |
| ** Find the shortest substrings occurring only once in <math>\Theta(n)</math> time.
| |
| ** Find, for each <math>i</math>, the shortest substrings of <math>S_i</math> not occurring elsewhere in <math>D</math> in <math>\Theta(n)</math> time.
| |
| | |
| The suffix tree can be prepared for constant time [[lowest common ancestor]] retrieval between nodes in <math>\Theta(n)</math> time.<ref>{{harvtxt|Gusfield|1999}}, Chapter 8.</ref> One can then also:
| |
| * Find the longest common prefix between the suffixes <math>S_i[p..n_i]</math> and <math>S_j[q..n_j]</math> in <math>\Theta(1)</math>.<ref>{{harvtxt|Gusfield|1999}}, p.196.</ref>
| |
| * Search for a pattern ''P'' of length ''m'' with at most ''k'' mismatches in <math>O(k n + z)</math> time, where ''z'' is the number of hits.<ref>{{harvtxt|Gusfield|1999}}, p.200.</ref>
| |
| * Find all <math>z</math> maximal [[palindrome]]s in <math>\Theta(n)</math>,<ref>{{harvtxt|Gusfield|1999}}, p.198.</ref> or <math>\Theta(g n)</math> time if gaps of length <math>g</math> are allowed, or <math>\Theta(k n)</math> if <math>k</math> mismatches are allowed.<ref>{{harvtxt|Gusfield|1999}}, p.201.</ref>
| |
| * Find all <math>z</math> [[tandem repeats]] in <math>O(n \log n + z)</math>, and ''k''-mismatch tandem repeats in <math>O(k n \log (n/k) + z)</math>.<ref>{{harvtxt|Gusfield|1999}}, p.204.</ref>
| |
| * Find the [[longest common substring problem|longest substrings common]] to at least <math>k</math> strings in <math>D</math> for <math>k=2,\dots,K</math> in <math>\Theta(n)</math> time.<ref>{{harvtxt|Gusfield|1999}}, p.205.</ref>
| |
| * Find the [[longest palindromic substring]] of a given string (using the suffix trees of both the string and its reverse) in linear time.<ref>{{harvtxt|Gusfield|1999}}, pp.197–199.</ref>
| |
| | |
| == Applications ==
| |
| 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.<ref name="allisons"/> Primary applications include:<ref name="allisons">{{cite web|url=http://www.allisons.org/ll/AlgDS/Tree/Suffix/|title=Suffix Trees|last=Allison|first=L. |accessdate=2008-10-14}}</ref>
| |
| * [[String search#Index methods|String search]], in ''O(m)'' complexity, where ''m'' is the length of the sub-string (but with initial ''O(n)'' time required to build the suffix tree for the string)
| |
| * Finding the longest repeated substring
| |
| * Finding the longest common substring
| |
| * Finding the longest [[palindrome]] in a string
| |
| | |
| Suffix trees are often used in [[bioinformatics]] applications, searching for patterns in [[DNA]] or [[protein]] 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 in [[data compression]]; they can be used to find repeated data, and can be used for the sorting stage of the [[Burrows–Wheeler transform]]. Variants of the [[LZW]] compression schemes use suffix trees ([[LZSS]]). A suffix tree is also used in [[suffix tree clustering]], a [[data clustering]] algorithm used in some search engines.<ref>First introduced by {{harvtxt|Zamir|Etzioni|1998}}.</ref>
| |
| | |
| ==Implementation==
| |
| If each node and edge can be represented in <math>\Theta(1)</math> space, the entire tree can be represented in <math>\Theta(n)</math> space. The total length of all the strings on all of the edges in the tree is <math>O(n^2)</math>, but each edge can be stored as the position and length of a substring of ''S'', giving a total space usage of <math>\Theta(n)</math> computer words. The worst-case space usage of a suffix tree is seen with a [[fibonacci word]], giving the full <math>2n</math> nodes.
| |
| | |
| An important choice when making a suffix tree implementation is the parent-child relationships between nodes. The most common is using [[linked list]]s called '''sibling 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 use [[hash map]]s, sorted or unsorted [[array data structure|array]]s (with [[dynamic array|array doubling]]), or [[Self-balancing binary search tree|balanced search tree]]s. 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 <math>\sigma</math> be the size of the alphabet. Then you have the following costs:
| |
| | |
| {|
| |
| !
| |
| ! Lookup
| |
| ! Insertion
| |
| ! Traversal
| |
| |-
| |
| ! Sibling lists / unsorted arrays
| |
| | <math>O(\sigma)</math>
| |
| | <math>\Theta(1)</math>
| |
| | <math>\Theta(1)</math>
| |
| |-
| |
| ! Hash maps
| |
| | <math>\Theta(1)</math>
| |
| | <math>\Theta(1)</math>
| |
| | <math>O(\sigma)</math>
| |
| |-
| |
| ! Balanced search tree
| |
| | <math>O(\log \sigma)</math>
| |
| | <math>O(\log \sigma)</math>
| |
| | <math>O(1)</math>
| |
| |-
| |
| ! Sorted arrays
| |
| | <math>O(\log \sigma)</math>
| |
| | <math>O(\sigma)</math>
| |
| | <math>O(1)</math>
| |
| |-
| |
| ! Hash maps + sibling lists
| |
| | <math>O(1)</math>
| |
| | <math>O(1)</math>
| |
| | <math>O(1)</math>
| |
| |}
| |
| | |
| Note that 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. The [[suffix array]] reduces this requirement to a factor of 8 (for array including [[LCP array|LCP]] 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 some UNIX-like systems, see [[wchar t]]) on 32-bit systems. Researchers have continued to find smaller indexing structures. | |
| | |
| ==External construction==
| |
| | |
| Suffix trees quickly outgrow the main memory on standard machines
| |
| for sequence collections in the order of gigabytes. As such, their
| |
| construction
| |
| calls for external memory approaches.
| |
| | |
| There are theoretical results for constructing suffix trees in external
| |
| memory.
| |
| The algorithm by {{harvtxt|Farach-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, its
| |
| practical implementation.{{sfnp|Smyth|2003}}
| |
| | |
| On the other hand, there have been practical works for constructing
| |
| disk-based suffix trees
| |
| which scale to (few) GB/hours.
| |
| The state of the art methods are TDD,<ref name="tdd">{{harvtxt|Tata|Hankins|Patel|2003}}.</ref>
| |
| TRELLIS,<ref name="trellis">{{harvtxt|Phoophakdee|Zaki|2007}}.</ref>
| |
| DiGeST,<ref name="digest">{{harvtxt|Barsky|Stege|Thomo|Upton|2008}}.</ref>
| |
| and | |
| B<sup>2</sup>ST.<ref name="b2st">{{harvtxt|Barsky|Stege|Thomo|Upton|2009}}.</ref>
| |
| | |
| TDD and TRELLIS scale up to the entire human genome – approximately 3GB – resulting in a disk-based suffix tree of a size in the tens of gigabytes,.<ref name="tdd" /><ref name="trellis" /> However, these methods cannot handle efficiently collections of sequences exceeding 3GB.<ref name="digest" /> DiGeST performs significantly better and is able to handle collections of sequences in the order of 6GB in about 6 hours.<ref name="digest" />
| |
| .
| |
| All these methods can efficiently build suffix trees for the case when the
| |
| tree does not fit in main memory,
| |
| but the input does.
| |
| The most recent method, B<sup>2</sup>ST,<ref name="b2st" /> scales to handle
| |
| inputs 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 16GB RAM. On a simple Linux cluster with 16 nodes (4GB RAM per node), ERA can index the entire human genome in less than 9 minutes.{{sfnp|Mansour|Allam|Skiadopoulos|Kalnis|2011}}
| |
| | |
| ==See also==
| |
| * [[Suffix array]]
| |
| * [[Generalised suffix tree]]
| |
| * [[Trie]]
| |
| | |
| ==Notes==
| |
| {{reflist|colwidth=30em}}
| |
| | |
| ==References==
| |
| *{{citation
| |
| | last1 = Baeza-Yates | first1 = Ricardo A. | author1-link = Ricardo Baeza-Yates
| |
| | last2 = Gonnet | first2 = Gaston H. | author2-link = Gaston Gonnet
| |
| | doi = 10.1145/235809.235810
| |
| | issue = 6
| |
| | journal = [[Journal of the ACM]]
| |
| | pages = 915–936
| |
| | title = Fast text searching for regular expressions or automaton searching on tries
| |
| | volume = 43
| |
| | year = 1996}}.
| |
| *{{citation
| |
| | last1 = Barsky | first1 = Marina
| |
| | last2 = Stege | first2 = Ulrike
| |
| | last3 = Thomo | first3 = Alex
| |
| | last4 = Upton | first4 = Chris
| |
| | contribution = A new method for indexing genomes using on-disk suffix trees
| |
| | location = New York, NY, USA
| |
| | pages = 649–658
| |
| | publisher = ACM
| |
| | title = CIKM '08: Proceedings of the 17th ACM Conference on Information and Knowledge Management
| |
| | year = 2008}}.
| |
| *{{citation
| |
| | last1 = Barsky | first1 = Marina
| |
| | last2 = Stege | first2 = Ulrike
| |
| | last3 = Thomo | first3 = Alex
| |
| | last4 = Upton | first4 = Chris
| |
| | contribution = Suffix trees for very large genomic sequences
| |
| | location = New York, NY, USA
| |
| | publisher = ACM
| |
| | title = CIKM '09: Proceedings of the 18th ACM Conference on Information and Knowledge Management
| |
| | year = 2009}}.
| |
| *{{citation
| |
| | last = Farach | first = Martin
| |
| | title = [[Symposium on Foundations of Computer Science|38th IEEE Symposium on Foundations of Computer Science (FOCS '97)]]
| |
| | pages = 137–143
| |
| | contribution = Optimal Suffix Tree Construction with Large Alphabets
| |
| | url = http://www.cs.rutgers.edu/~farach/pubs/Suffix.pdf
| |
| | year = 1997}}.
| |
| *{{citation
| |
| | last1 = Farach-Colton | first1 = Martin
| |
| | last2 = Ferragina | first2 = Paolo
| |
| | last3 = Muthukrishnan | first3 = S.
| |
| | doi = 10.1145/355541.355547
| |
| | issue = 6
| |
| | journal = Journal of the ACM
| |
| | pages = 987–1011
| |
| | title = On the sorting-complexity of suffix tree construction.
| |
| | volume = 47
| |
| | year = 2000}}.
| |
| *{{citation
| |
| | last1 = Giegerich | first1 = R.
| |
| | last2 = Kurtz | first2 = S.
| |
| | doi = 10.1007/PL00009177
| |
| | issue = 3
| |
| | journal = [[Algorithmica]]
| |
| | pages = 331–353
| |
| | title = From Ukkonen to McCreight and Weiner: A Unifying View of Linear-Time Suffix Tree Construction
| |
| | url = http://europa.zbh.uni-hamburg.de/pubs/pdf/GieKur1997.pdf
| |
| | volume = 19
| |
| | year = 1997}}.
| |
| *{{citation
| |
| | last = Gusfield | first = Dan
| |
| | isbn = 0-521-58519-8
| |
| | publisher = Cambridge University Press
| |
| | title = Algorithms on Strings, Trees and Sequences: Computer Science and Computational Biology
| |
| | year = 1999}}.
| |
| *{{citation
| |
| | last1 = Mansour | first1 = Essam
| |
| | last2 = Allam | first2 = Amin
| |
| | last3 = Skiadopoulos | first3 = Spiros
| |
| | last4 = Kalnis | first4 = Panos
| |
| | issue = 1
| |
| | journal = PVLDB
| |
| | pages = 49–60
| |
| | title = ERA: Efficient Serial and Parallel Suffix Tree Construction for Very Long Strings
| |
| | url = http://www.vldb.org/pvldb/vol5/p049_essammansour_vldb2012.pdf
| |
| | volume = 5
| |
| | year = 2011}}.
| |
| *{{citation
| |
| | last = McCreight | first = Edward M. | authorlink = Edward M. McCreight
| |
| | doi = 10.1145/321941.321946
| |
| | issue = 2
| |
| | journal = [[Journal of the ACM]]
| |
| | pages = 262–272
| |
| | title = A Space-Economical Suffix Tree Construction Algorithm
| |
| | volume = 23
| |
| | year = 1976}}.
| |
| *{{citation
| |
| | last1 = Phoophakdee | first1 = Benjarath
| |
| | last2 = Zaki | first2 = Mohammed J.
| |
| | contribution = Genome-scale disk-based suffix tree indexing
| |
| | location = New York, NY, USA
| |
| | pages = 833–844
| |
| | publisher = ACM
| |
| | title = SIGMOD '07: Proceedings of the ACM SIGMOD International Conference on Management of Data
| |
| | year = 2007}}.
| |
| *{{citation
| |
| | last = Smyth | first = William
| |
| | publisher = [[Addison-Wesley]]
| |
| | title = Computing Patterns in Strings
| |
| | year = 2003}}.
| |
| *{{citation
| |
| | last1 = Tata | first1 = Sandeep
| |
| | last2 = Hankins | first2 = Richard A.
| |
| | last3 = Patel | first3 = Jignesh M.
| |
| | contribution = Practical Suffix Tree Construction
| |
| | pages = 36–47
| |
| | publisher = Morgan Kaufmann
| |
| | title = VLDB '03: Proceedings of the 30th International Conference on Very Large Data Bases
| |
| | year = 2003}}.
| |
| *{{citation
| |
| | last = Ukkonen | first = E.
| |
| | doi = 10.1007/BF01206331
| |
| | issue = 3
| |
| | journal = [[Algorithmica]]
| |
| | pages = 249–260
| |
| | title = On-line construction of suffix trees
| |
| | url = http://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf
| |
| | volume = 14
| |
| | year = 1995}}.
| |
| *{{citation
| |
| | last = Weiner | first = P.
| |
| | contribution = Linear pattern matching algorithms
| |
| | doi = 10.1109/SWAT.1973.13
| |
| | pages = 1–11
| |
| | title = [[Symposium on Foundations of Computer Science|14th Annual IEEE Symposium on Switching and Automata Theory]]
| |
| | year = 1973}}.
| |
| *{{citation
| |
| | last1 = Zamir | first1 = Oren
| |
| | last2 = Etzioni | first2 = Oren
| |
| | authorlink2=Oren Etzioni
| |
| | contribution = Web document clustering: a feasibility demonstration
| |
| | location = New York, NY, USA
| |
| | pages = 46–54
| |
| | publisher = ACM
| |
| | title = SIGIR '98: Proceedings of the 21st annual international ACM SIGIR conference on Research and development in information retrieval
| |
| | year = 1998}}.
| |
| | |
| == External links ==
| |
| {{External links|date=August 2010}}
| |
| * [http://www.cise.ufl.edu/~sahni/dsaaj/enrich/c16/suffix.htm Suffix Trees] by [[Sartaj Sahni]]
| |
| * [http://www.allisons.org/ll/AlgDS/Tree/Suffix/ Suffix Trees] by Lloyd Allison
| |
| * [http://www.nist.gov/dads/HTML/suffixtree.html NIST's Dictionary of Algorithms and Data Structures: Suffix Tree]
| |
| * [http://mila.cs.technion.ac.il/~yona/suffix_tree/ suffix_tree] ANSI C implementation of a Suffix Tree
| |
| * [http://www.cl.cam.ac.uk/~cpk25/libstree/ libstree], a generic suffix tree library written in C
| |
| * [https://metacpan.org/module/Tree::Suffix Tree::Suffix], a Perl binding to libstree
| |
| * [http://www.cs.ucdavis.edu/~gusfield/strmat.html Strmat] a faster generic suffix tree library written in C (uses arrays instead of linked lists)
| |
| * [http://hkn.eecs.berkeley.edu/~dyoo/python/suffix_trees/ SuffixTree] a Python binding to Strmat
| |
| * [http://www.balkenhol.net/papers/t1043.pdf.gz Universal Data Compression Based on the Burrows-Wheeler Transformation: Theory and Practice], application of suffix trees in the BWT
| |
| * [http://www.cs.helsinki.fi/group/suds/ Theory and Practice of Succinct Data Structures], C++ implementation of a compressed suffix tree
| |
| * [http://code.google.com/p/patl/ Practical Algorithm Template Library], a C++ library with suffix tree implementation on PATRICIA trie, by Roman S. Klyujkov
| |
| * [http://en.literateprograms.org/Suffix_tree_(Java) A Java implementation]
| |
| * [http://code.google.com/p/concurrent-trees/ A Java implementation of Concurrent Suffix Tree]
| |
| * [http://code.google.com/p/text-indexing/ Text-Indexing project] (linear-time construction of suffix trees, suffix arrays, LCP array and Burrows-Wheeler Transform)
| |
| {{CS-Trees}}
| |
| | |
| {{DEFAULTSORT:Suffix Tree}}
| |
| [[Category:Trees (data structures)]]
| |
| [[Category:Substring indices]]
| |
| [[Category:String data structures]]
| |