Open main menu

In computer science, a suffix array is a sorted array of all suffixes of a string. It is a data structure used, among others, in full text indices, data compression algorithms and within the field of bibliometrics.

Suffix array
Type Array
Invented by Manber & Myers (1990)
Average Worst case
Space
Construction

Suffix arrays were introduced by Manber & Myers (1990) as a simple, space efficient alternative to suffix trees. They had independently been discovered by Gaston Gonnet in 1987 under the name PAT array (Gonnet, Baeza-Yates & Snider 1992).

Li, Li & Huo (2016) gave the first in-place time suffix array construction algorithm that is optimal both in time and space, where in-place means that the algorithm only needs additional space beyond the input string and the output suffix array.

Enhanced suffix arrays (ESAs) are suffix arrays with additional tables that reproduce the full functionality of suffix trees preserving the same time and memory complexity.[1] The suffix array for a subset of all suffixes of a string is called sparse suffix array.[2] Multiple probabilistic algorithms have been developed to minimize the additional memory usage including an optimal time and memory algorithm[3].

Contents

DefinitionEdit

Let   be a string and let   denote the substring of   ranging from   to  .

The suffix array   of   is now defined to be an array of integers providing the starting positions of suffixes of   in lexicographical order. This means, an entry   contains the starting position of the  -th smallest suffix in   and thus for all  :  .

ExampleEdit

Consider the text  =banana$ to be indexed:

i 1 2 3 4 5 6 7
  b a n a n a $

The text ends with the special sentinel letter $ that is unique and lexicographically smaller than any other character. The text has the following suffixes:

Suffix i
banana$ 1
anana$ 2
nana$ 3
ana$ 4
na$ 5
a$ 6
$ 7

These suffixes can be sorted in ascending order:

Suffix i
$ 7
a$ 6
ana$ 4
anana$ 2
banana$ 1
na$ 5
nana$ 3

The suffix array   contains the starting positions of these sorted suffixes:

i 1 2 3 4 5 6 7
  7 6 4 2 1 5 3

The suffix array with the suffixes written out vertically underneath for clarity:

i 1 2 3 4 5 6 7
  7 6 4 2 1 5 3
1 $ a a a b n n
2 $ n n a a a
3 a a n $ n
4 $ n a a
5 a n $
6 $ a
7 $

So for example,   contains the value 4, and therefore refers to the suffix starting at position 4 within  , which is the suffix ana$.

Correspondence to suffix treesEdit

Suffix arrays are closely related to suffix trees:

  • Suffix arrays can be constructed by performing a depth-first traversal of a suffix tree. The suffix array corresponds to the leaf-labels given in the order in which these are visited during the traversal, if edges are visited in the lexicographical order of their first character.
  • A suffix tree can be constructed in linear time by using a combination of suffix array and LCP array. For a description of the algorithm, see the corresponding section in the LCP array article.

It has been shown that every suffix tree algorithm can be systematically replaced with an algorithm that uses a suffix array enhanced with additional information (such as the LCP array) and solves the same problem in the same time complexity.[4] Advantages of suffix arrays over suffix trees include improved space requirements, simpler linear time construction algorithms (e.g., compared to Ukkonen's algorithm) and improved cache locality.[5]

Space EfficiencyEdit

Suffix arrays were introduced by Manber & Myers (1990) in order to improve over the space requirements of suffix trees: Suffix arrays store   integers. Assuming an integer requires   bytes, a suffix array requires   bytes in total. This is significantly less than the   bytes which are required by a careful suffix tree implementation.[6]

However, in certain applications, the space requirements of suffix arrays may still be prohibitive. Analyzed in bits, a suffix array requires   space, whereas the original text over an alphabet of size   only requires   bits. For a human genome with   and   the suffix array would therefore occupy about 16 times more memory than the genome itself.

Such discrepancies motivated a trend towards compressed suffix arrays and BWT-based compressed full-text indices such as the FM-index. These data structures require only space within the size of the text or even less.

Construction AlgorithmsEdit

A suffix tree can be built in   and can be converted into a suffix array by traversing the tree depth-first also in  , so there exist algorithms that can build a suffix array in  .

A naive approach to construct a suffix array is to use a comparison-based sorting algorithm. These algorithms require   suffix comparisons, but a suffix comparison runs in   time, so the overall runtime of this approach is  .

More advanced algorithms take advantage of the fact that the suffixes to be sorted are not arbitrary strings but related to each other. These algorithms strive to achieve the following goals:[7]

  • minimal asymptotic complexity  
  • lightweight in space, meaning little or no working memory beside the text and the suffix array itself is needed
  • fast in practice

One of the first algorithms to achieve all goals is the SA-IS algorithm of Nong, Zhang & Chan (2009). The algorithm is also rather simple (< 100 LOC) and can be enhanced to simultaneously construct the LCP array.[8] The SA-IS algorithm is one of the fastest known suffix array construction algorithms. A careful implementation by Yuta Mori outperforms most other linear or super-linear construction approaches.

Beside time and space requirements, suffix array construction algorithms are also differentiated by their supported alphabet: constant alphabets where the alphabet size is bound by a constant, integer alphabets where characters are integers in a range depending on   and general alphabets where only character comparisons are allowed.[9]

Most suffix array construction algorithms are based on one of the following approaches:[7]

  • Prefix doubling algorithms are based on a strategy of Karp, Miller & Rosenberg (1972). The idea is to find prefixes that honor the lexicographic ordering of suffixes. The assessed prefix length doubles in each iteration of the algorithm until a prefix is unique and provides the rank of the associated suffix.
  • Recursive algorithms follow the approach of the suffix tree construction algorithm by Farach (1997) to recursively sort a subset of suffixes. This subset is then used to infer a suffix array of the remaining suffixes. Both of these suffix arrays are then merged to compute the final suffix array.
  • Induced copying algorithms are similar to recursive algorithms in the sense that they use an already sorted subset to induce a fast sort of the remaining suffixes. The difference is that these algorithms favor iteration over recursion to sort the selected suffix subset. A survey of this diverse group of algorithms has been put together by Puglisi, Smyth & Turpin (2007).

A well-known recursive algorithm for integer alphabets is the DC3 / skew algorithm of Kärkkäinen & Sanders (2003). It runs in linear time and has successfully been used as the basis for parallel[10] and external memory[11] suffix array construction algorithms.

Recent work by Salson et al. (2009) proposes an algorithm for updating the suffix array of a text that has been edited instead of rebuilding a new suffix array from scratch. Even if the theoretical worst-case time complexity is  , it appears to perform well in practice: experimental results from the authors showed that their implementation of dynamic suffix arrays is generally more efficient than rebuilding when considering the insertion of a reasonable number of letters in the original text.

ApplicationsEdit

The suffix array of a string can be used as an index to quickly locate every occurrence of a substring pattern   within the string  . Finding every occurrence of the pattern is equivalent to finding every suffix that begins with the substring. Thanks to the lexicographical ordering, these suffixes will be grouped together in the suffix array and can be found efficiently with two binary searches. The first search locates the starting position of the interval, and the second one determines the end position:

    n = len(S)
    def search(P):
        l = 0; r = n
        while l < r:
            mid = (l+r) / 2
            if P > suffixAt(A[mid]):
                l = mid + 1
            else:
                r = mid
        s = l; r = n
        while l < r:
            mid = (l+r) / 2
            if P < suffixAt(A[mid]):
                r = mid
            else:
                l = mid + 1
        return (s, r)

Finding the substring pattern   of length   in the string   of length   takes   time, given that a single suffix comparison needs to compare   characters. Manber & Myers (1990) describe how this bound can be improved to   time using LCP information. The idea is that a pattern comparison does not need to re-compare certain characters, when it is already known that these are part of the longest common prefix of the pattern and the current search interval. Abouelhoda, Kurtz & Ohlebusch (2004) improve the bound even further and achieve a search time of   as known from suffix trees.

Suffix sorting algorithms can be used to compute the Burrows–Wheeler transform (BWT). The BWT requires sorting of all cyclic permutations of a string. If this string ends in a special end-of-string character that is lexicographically smaller than all other character (i.e., $), then the order of the sorted rotated BWT matrix corresponds to the order of suffixes in a suffix array. The BWT can therefore be computed in linear time by first constructing a suffix array of the text and then deducing the BWT string:  .

Suffix arrays can also be used to look up substrings in Example-Based Machine Translation, demanding much less storage than a full phrase table as used in Statistical machine translation.

Many additional applications of the suffix array require the LCP array. Some of these are detailed in the application section of the latter.

NotesEdit

  1. ^ Abouelhoda, Mohamed Ibrahim; Kurtz, Stefan; Ohlebusch, Enno (2004-03). "Replacing suffix trees with enhanced suffix arrays". Journal of Discrete Algorithms. 2 (1): 53–86. doi:10.1016/s1570-8667(03)00065-0. ISSN 1570-8667. Check date values in: |date= (help)
  2. ^ Kärkkäinen, Juha; Ukkonen, Esko (1996), "Sparse suffix trees", Lecture Notes in Computer Science, Springer Berlin Heidelberg, pp. 219–230, doi:10.1007/3-540-61332-3_155, ISBN 9783540613329, retrieved 2018-07-12
  3. ^ Gawrychowski, Paweł; Kociumaka, Tomasz (2017-01). "Sparse Suffix Tree Construction in Optimal Time and Space". Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms. Philadelphia, PA: Society for Industrial and Applied Mathematics. ISBN 9781611974782. Check date values in: |date= (help)
  4. ^ Abouelhoda, Kurtz & Ohlebusch 2004.
  5. ^ Abouelhoda, Kurtz & Ohlebusch 2002.
  6. ^ Kurtz 1999.
  7. ^ a b Puglisi, Smyth & Turpin 2007.
  8. ^ Fischer 2011.
  9. ^ Burkhardt & Kärkkäinen 2003.
  10. ^ Kulla & Sanders 2007.
  11. ^ Dementiev et al. 2008.

ReferencesEdit

External linksEdit