Алгоритм дерева суффиксов Ukkonen на простом английском языке

я попытался реализовать дерево суффиксов с подходом, приведенным в ответе jogojapan, но это не сработало для некоторых случаев из-за формулировки, используемой для правил. Более того, я упомянул, что никому не удалось реализовать абсолютно правильное дерево суффиксов, используя этот подход. Ниже я напишу "обзор" ответа jogojapan с некоторыми изменениями в правилах. Я также опишу случай, когда мы забываем создать важно суффикс связи.

используются дополнительные переменные

1. активные точки - тройка (active_node; active_edge; active_length), показывающая, откуда мы должны начать вставлять новый суффикс.
2. остаток - показывает количество суффиксов, которые мы должны добавить явно. Например, если наше слово "abcaabca", а остаток = 3, это означает, что мы должны обработать 3 последних суффикса:bca, ca и a.

давайте использовать понятие внутренний узел - все узлы, кроме root и листья are внутренние узлы.

наблюдение 1

когда последний суффикс, который нам нужно вставить, уже существует в дереве, само дерево не изменяется вообще (мы только обновляем active point и remainder).

наблюдение 2

если в какой-то момент active_length больше или равно длине текущего ребра (edge_length), мы двигаем active point до edge_length строго больше active_length.

теперь, давайте определим правила:

Правило 1

если после вставки из активный узел = root, the активная длина is больше 0, то:

1. активный узел не менял
2. активная длина уменьшается
3. активный краю смещается вправо (к первому символу следующего суффикса надо вставить)

Правило 2

если мы создадим новый внутренний узел или сделайте inserter от внутренний узел и это не первый такие внутренний узел на текущем шаге, то мы связываем предыдущий такие узел этой через суффикс ссылке.

данное определение Rule 2 отличается от jogojapan', так как здесь мы учитываем не только вновь созданный внутренние узлы, но и внутренние узлы, из которых мы делаем вставка.

Правило 3

после вставки из активный узел это не root узел, мы должны следовать ссылке суффикса и установить активный узел к узлу, на который он указывает. Если нет суффиксной ссылки, установите активный узел до root узел. В любом случае, активный краю и активная длина отдых не менявшийся.

в этом определении Rule 3 мы также рассматриваем вставки листовых узлов (не только сплит-узлов).

и, наконец, наблюдение 3:

когда символ, который мы хотим добавить к дереву, уже находится на краю, мы, согласно Observation 1 обновление только active point и remainder, оставив дерево без изменений. но если есть внутренний узел помечен как требуется суффикс ссылка, мы должны соединить этот узел с нашим текущим active node по суффиксной ссылке.

давайте рассмотрим пример дерева суффиксов для cdddcdc если мы добавим суффиксную ссылку в таком случае, и если мы этого не сделаем:

1. если мы НЕ соедините узлы через суффиксную ссылку:

   • перед добавлением последней буквы c:

   

   • после добавления последняя буква c:

   

2. если мы DO соедините узлы через суффиксную ссылку:

   • перед добавлением последней буквы c:

   

   • после добавления последней буквы c:

   

кажется, что нет существенной отличие: во втором случае есть еще две суффикс-ссылки. Но эти суффиксные ссылки являются правильно, и один из них - от синего узла до Красного-очень важно для нашего подхода с активные точки. Проблема в том, что если мы не поместим суффиксную ссылку здесь, позже, когда мы добавим некоторые новые буквы в дерево, мы можем опустить добавление некоторых узлов в дерево из-за Rule 3, потому что, согласно ему, если нет суффиксной ссылки, то мы должен поставить active_node в корень.

когда мы добавляли последнюю букву к дереву, Красный Узел имел существовала прежде чем мы сделали вставку из синего узла (край labled 'c'). Поскольку была вставка из синего узла, мы отмечаем ее как требуется суффикс ссылка. Тогда, полагаясь на активные точки подход active node был установлен в Красный Узел. Но мы не делаем вставку из красного узла, так как письмо!--17--> 'c' уже на краю. Означает ли это, что синий узел должен быть оставлен без суффиксной ссылки? Нет, мы должны соединить синий узел с красным через суффиксную ссылку. Почему это правильно? Потому что активные точки подход гарантирует, что мы попадем в нужное место, т. е. в следующее место, где мы должны обработать вставку короче суффиксом.

наконец, вот мои реализации суффикс Дерево:

1. Java
2. C++

надеюсь, что этот "обзор" в сочетании с подробным ответом jogojapan поможет кому-то реализовать свое собственное дерево суффиксов.

Спасибо за хорошо объясненный учебник по @jogojapan, я реализовал алгоритм в Python.

пара незначительных проблем, упомянутых @jogojapan, оказывается больше сложные чем я ожидал, и к нему нужно относиться очень осторожно. Это стоило мне нескольких дней, чтобы получить мою реализацию достаточно (Я полагаю). Проблемы и решения перечислены ниже:

1. конец с Remainder > 0 оказывается, эта ситуация также может произойти во время разворачивания шага, а не только конец всего алгоритма. Когда это произойдет, мы можем оставить остаток, actnode, actedge и actlength без изменений, завершите текущий шаг развертывания и начните другой шаг, либо продолжайте сворачивать или разворачивать в зависимости от того, находится ли следующий символ в исходной строке на текущем пути или нет.

2. Прыжок Через Узлы: Когда мы следуем по ссылке суффикса, обновите активную точку, а затем обнаружите, что ее компонент active_length не работает хорошо с новым active_node. Мы должны!--2-->шаг вперед в нужное место, чтобы разделить или вставить лист. Этот процесс может быть не так просто потому что во время перемещения actlength и actedge постоянно меняются, когда вам нужно вернуться к корневой узел на actedge и actlength может быть неправильно из-за этих движений. Нам понадобится дополнительная переменная(ы), чтобы сохранить эту информацию.

   

две другие проблемы каким-то образом были указаны @managonov

1. Сплит Может Вырождаться при попытке разделить ребро, когда-нибудь вы обнаружите, что операция разделения находится прямо на узле. Этом случае нам нужно только добавить новый лист к этому узлу, берут это как стандартная операция разделения края, что означает, что суффиксные ссылки, если они есть, должны поддерживаться соответственно.

2. Скрытые Ссылки Суффикса есть еще один частный случай, который возникает 1 и 2. Иногда нам нужно перепрыгнуть через несколько узлов в нужную точку для split, мы могли бы перегнать правильная точка, если мы перемещаемся, сравнивая оставшуюся строку и метки пути. Что случай суффикс ссылка будет пренебрегаться непреднамеренно,если они должны быть. Этого можно было избежать запоминание правильной точки при движении вперед. Связь суффиксов должна поддерживаться, если разделенный узел уже существует или даже 1 происходит во время раскладывания шаг.

наконец, моя реализация в Python следующим образом:

• Python

советы: он включает в себя наивный печать дерево в коде выше, что очень важно при отладке. Он спас меня много время и удобно для обнаруживать местонахождение специальные случаи.

моя интуиция такова:

после K итераций основного цикла вы построили дерево суффиксов, которое содержит все суффиксы полной строки, которые начинаются с первых k символов.

в начале, это означает, что суффиксное дерево содержит один корневой узел, представляющий всю строку (это единственный суффикс, который начинается с 0).

после итераций LEN (string) у вас есть дерево суффиксов, которое содержит все суффиксы.

во время цикла ключ является активной точкой. Я предполагаю, что это самая глубокая точка в дереве суффиксов, которая соответствует правильному суффиксу первых k символов строки. (Я думаю, что правильный означает, что суффикс не может быть всей строкой.)

например, предположим, что вы видели символы 'abcabc'. Активная точка будет представлять собой точку в дереве, соответствующую суффиксу "abc".

активная точка представлен (origin, first, last). Это означает, что в данный момент Вы находитесь в точке дерева, которую вы получаете, начиная с начала узла, а затем вводя символы в строке[first:last]

когда вы добавляете новый символ, вы смотрите, находится ли активная точка в существующем дереве. Если это так, то с вами покончено. В противном случае вам нужно добавить новый узел в дерево суффиксов в активной точке, вернуться к следующему кратчайшему совпадению и проверить еще раз.

Примечание. Один: Указатели суффиксов дают ссылку на следующее кратчайшее совпадение для каждого узла.

примечание 2: При добавлении нового узла и резервного добавляется новый указатель суффикса для нового узла. Конечным пунктом для этого указателя суффикса будет узел в укороченной активной точке. Этот узел либо уже существует, либо будет создан на следующей итерации этого резервного цикла.

Примечание 3: часть канонизации просто сохраняет время в проверять активную точку. Например, предположим, что вы всегда используется origin=0 и просто изменяется первым и последним. Чтобы проверить активную точку, вам нужно будет каждый раз следовать дереву суффиксов вдоль всех промежуточных узлов. Имеет смысл кэшировать результаты по этому пути, записывая только расстояние от последнего узла.

можете ли вы привести пример кода того, что вы подразумеваете под "исправлением" ограничивающих переменных?

предупреждение о здоровье: я также нашел этот алгоритм особенно трудно понять, поэтому, пожалуйста, поймите, что эта интуиция вероятно, будут неверны во всех важных деталях...

Привет я попытался реализовать вышеописанную реализацию в ruby, пожалуйста, проверьте это. кажется, это работает нормально.

единственная разница в реализации заключается в том, что я попытался использовать объект edge вместо использования символов.

его на https://gist.github.com/suchitpuri/9304856

    require 'pry'


class Edge
    attr_accessor :data , :edges , :suffix_link
    def initialize data
        @data = data
        @edges = []
        @suffix_link = nil
    end

    def find_edge element
        self.edges.each do |edge|
            return edge if edge.data.start_with? element
        end
        return nil
    end
end

class SuffixTrees
    attr_accessor :root , :active_point , :remainder , :pending_prefixes , :last_split_edge , :remainder

    def initialize
        @root = Edge.new nil
        @active_point = { active_node: @root , active_edge: nil , active_length: 0}
        @remainder = 0
        @pending_prefixes = []
        @last_split_edge = nil
        @remainder = 1
    end

    def build string
        string.split("").each_with_index do |element , index|


            add_to_edges @root , element        

            update_pending_prefix element                           
            add_pending_elements_to_tree element
            active_length = @active_point[:active_length]

            # if(@active_point[:active_edge] && @active_point[:active_edge].data && @active_point[:active_edge].data[0..active_length-1] ==  @active_point[:active_edge].data[active_length..@active_point[:active_edge].data.length-1])
            #   @active_point[:active_edge].data = @active_point[:active_edge].data[0..active_length-1]
            #   @active_point[:active_edge].edges << Edge.new(@active_point[:active_edge].data)
            # end

            if(@active_point[:active_edge] && @active_point[:active_edge].data && @active_point[:active_edge].data.length == @active_point[:active_length]  )
                @active_point[:active_node] =  @active_point[:active_edge]
                @active_point[:active_edge] = @active_point[:active_node].find_edge(element[0])
                @active_point[:active_length] = 0
            end
        end
    end

    def add_pending_elements_to_tree element

        to_be_deleted = []
        update_active_length = false
        # binding.pry
        if( @active_point[:active_node].find_edge(element[0]) != nil)
            @active_point[:active_length] = @active_point[:active_length] + 1               
            @active_point[:active_edge] = @active_point[:active_node].find_edge(element[0]) if @active_point[:active_edge] == nil
            @remainder = @remainder + 1
            return
        end



        @pending_prefixes.each_with_index do |pending_prefix , index|

            # binding.pry           

            if @active_point[:active_edge] == nil and @active_point[:active_node].find_edge(element[0]) == nil

                @active_point[:active_node].edges << Edge.new(element)

            else

                @active_point[:active_edge] = node.find_edge(element[0]) if @active_point[:active_edge]  == nil

                data = @active_point[:active_edge].data
                data = data.split("")               

                location = @active_point[:active_length]


                # binding.pry
                if(data[0..location].join == pending_prefix or @active_point[:active_node].find_edge(element) != nil )                  


                else #tree split    
                    split_edge data , index , element
                end

            end
        end 
    end



    def update_pending_prefix element
        if @active_point[:active_edge] == nil
            @pending_prefixes = [element]
            return

        end

        @pending_prefixes = []

        length = @active_point[:active_edge].data.length
        data = @active_point[:active_edge].data
        @remainder.times do |ctr|
                @pending_prefixes << data[-(ctr+1)..data.length-1]
        end

        @pending_prefixes.reverse!

    end

    def split_edge data , index , element
        location = @active_point[:active_length]
        old_edges = []
        internal_node = (@active_point[:active_edge].edges != nil)

        if (internal_node)
            old_edges = @active_point[:active_edge].edges 
            @active_point[:active_edge].edges = []
        end

        @active_point[:active_edge].data = data[0..location-1].join                 
        @active_point[:active_edge].edges << Edge.new(data[location..data.size].join)


        if internal_node
            @active_point[:active_edge].edges << Edge.new(element)
        else
            @active_point[:active_edge].edges << Edge.new(data.last)        
        end

        if internal_node
            @active_point[:active_edge].edges[0].edges = old_edges
        end


        #setup the suffix link
        if @last_split_edge != nil and @last_split_edge.data.end_with?@active_point[:active_edge].data 

            @last_split_edge.suffix_link = @active_point[:active_edge] 
        end

        @last_split_edge = @active_point[:active_edge]

        update_active_point index

    end


    def update_active_point index
        if(@active_point[:active_node] == @root)
            @active_point[:active_length] = @active_point[:active_length] - 1
            @remainder = @remainder - 1
            @active_point[:active_edge] = @active_point[:active_node].find_edge(@pending_prefixes.first[index+1])
        else
            if @active_point[:active_node].suffix_link != nil
                @active_point[:active_node] = @active_point[:active_node].suffix_link               
            else
                @active_point[:active_node] = @root
            end 
            @active_point[:active_edge] = @active_point[:active_node].find_edge(@active_point[:active_edge].data[0])
            @remainder = @remainder - 1     
        end
    end

    def add_to_edges root , element     
        return if root == nil
        root.data = root.data + element if(root.data and root.edges.size == 0)
        root.edges.each do |edge|
            add_to_edges edge , element
        end
    end
end

suffix_tree = SuffixTrees.new
suffix_tree.build("abcabxabcd")
binding.pry

@jogojapan вы принесли удивительное объяснение и визуализацию. Но, как отметил @makagonov, отсутствуют некоторые правила, касающиеся установки суффиксных ссылок. Это видно в хорошем смысле, когда идет шаг за шагом на http://brenden.github.io/ukkonen-animation/ через слово "aabaaabb". Когда вы переходите от шага 10 к шагу 11, нет суффиксной ссылки от узла 5 к узлу 2, но активная точка внезапно перемещается туда.

@makagonov так как я живу в мире Java, я также пытался следовать за вашим реализация для понимания рабочего процесса St building, но мне было трудно из-за:

• объединение ребер с узлами
• использование указателей индекса вместо ссылок
• разрывы заявления;
• продолжить высказывания;

таким образом, я закончил с такой реализацией на Java, которая, я надеюсь, отражает все шаги более ясным образом и сократит время обучения для других людей Java:

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class ST {

  public class Node {
    private final int id;
    private final Map<Character, Edge> edges;
    private Node slink;

    public Node(final int id) {
        this.id = id;
        this.edges = new HashMap<>();
    }

    public void setSlink(final Node slink) {
        this.slink = slink;
    }

    public Map<Character, Edge> getEdges() {
        return this.edges;
    }

    public Node getSlink() {
        return this.slink;
    }

    public String toString(final String word) {
        return new StringBuilder()
                .append("{")
                .append("\"id\"")
                .append(":")
                .append(this.id)
                .append(",")
                .append("\"slink\"")
                .append(":")
                .append(this.slink != null ? this.slink.id : null)
                .append(",")
                .append("\"edges\"")
                .append(":")
                .append(edgesToString(word))
                .append("}")
                .toString();
    }

    private StringBuilder edgesToString(final String word) {
        final StringBuilder edgesStringBuilder = new StringBuilder();
        edgesStringBuilder.append("{");
        for(final Map.Entry<Character, Edge> entry : this.edges.entrySet()) {
            edgesStringBuilder.append("\"")
                    .append(entry.getKey())
                    .append("\"")
                    .append(":")
                    .append(entry.getValue().toString(word))
                    .append(",");
        }
        if(!this.edges.isEmpty()) {
            edgesStringBuilder.deleteCharAt(edgesStringBuilder.length() - 1);
        }
        edgesStringBuilder.append("}");
        return edgesStringBuilder;
    }

    public boolean contains(final String word, final String suffix) {
        return !suffix.isEmpty()
                && this.edges.containsKey(suffix.charAt(0))
                && this.edges.get(suffix.charAt(0)).contains(word, suffix);
    }
  }

  public class Edge {
    private final int from;
    private final int to;
    private final Node next;

    public Edge(final int from, final int to, final Node next) {
        this.from = from;
        this.to = to;
        this.next = next;
    }

    public int getFrom() {
        return this.from;
    }

    public int getTo() {
        return this.to;
    }

    public Node getNext() {
        return this.next;
    }

    public int getLength() {
        return this.to - this.from;
    }

    public String toString(final String word) {
        return new StringBuilder()
                .append("{")
                .append("\"content\"")
                .append(":")
                .append("\"")
                .append(word.substring(this.from, this.to))
                .append("\"")
                .append(",")
                .append("\"next\"")
                .append(":")
                .append(this.next != null ? this.next.toString(word) : null)
                .append("}")
                .toString();
    }

    public boolean contains(final String word, final String suffix) {
        if(this.next == null) {
            return word.substring(this.from, this.to).equals(suffix);
        }
        return suffix.startsWith(word.substring(this.from,
                this.to)) && this.next.contains(word, suffix.substring(this.to - this.from));
    }
  }

  public class ActivePoint {
    private final Node activeNode;
    private final Character activeEdgeFirstCharacter;
    private final int activeLength;

    public ActivePoint(final Node activeNode,
                       final Character activeEdgeFirstCharacter,
                       final int activeLength) {
        this.activeNode = activeNode;
        this.activeEdgeFirstCharacter = activeEdgeFirstCharacter;
        this.activeLength = activeLength;
    }

    private Edge getActiveEdge() {
        return this.activeNode.getEdges().get(this.activeEdgeFirstCharacter);
    }

    public boolean pointsToActiveNode() {
        return this.activeLength == 0;
    }

    public boolean activeNodeIs(final Node node) {
        return this.activeNode == node;
    }

    public boolean activeNodeHasEdgeStartingWith(final char character) {
        return this.activeNode.getEdges().containsKey(character);
    }

    public boolean activeNodeHasSlink() {
        return this.activeNode.getSlink() != null;
    }

    public boolean pointsToOnActiveEdge(final String word, final char character) {
        return word.charAt(this.getActiveEdge().getFrom() + this.activeLength) == character;
    }

    public boolean pointsToTheEndOfActiveEdge() {
        return this.getActiveEdge().getLength() == this.activeLength;
    }

    public boolean pointsAfterTheEndOfActiveEdge() {
        return this.getActiveEdge().getLength() < this.activeLength;
    }

    public ActivePoint moveToEdgeStartingWithAndByOne(final char character) {
        return new ActivePoint(this.activeNode, character, 1);
    }

    public ActivePoint moveToNextNodeOfActiveEdge() {
        return new ActivePoint(this.getActiveEdge().getNext(), null, 0);
    }

    public ActivePoint moveToSlink() {
        return new ActivePoint(this.activeNode.getSlink(),
                this.activeEdgeFirstCharacter,
                this.activeLength);
    }

    public ActivePoint moveTo(final Node node) {
        return new ActivePoint(node, this.activeEdgeFirstCharacter, this.activeLength);
    }

    public ActivePoint moveByOneCharacter() {
        return new ActivePoint(this.activeNode,
                this.activeEdgeFirstCharacter,
                this.activeLength + 1);
    }

    public ActivePoint moveToEdgeStartingWithAndByActiveLengthMinusOne(final Node node,
                                                                       final char character) {
        return new ActivePoint(node, character, this.activeLength - 1);
    }

    public ActivePoint moveToNextNodeOfActiveEdge(final String word, final int index) {
        return new ActivePoint(this.getActiveEdge().getNext(),
                word.charAt(index - this.activeLength + this.getActiveEdge().getLength()),
                this.activeLength - this.getActiveEdge().getLength());
    }

    public void addEdgeToActiveNode(final char character, final Edge edge) {
        this.activeNode.getEdges().put(character, edge);
    }

    public void splitActiveEdge(final String word,
                                final Node nodeToAdd,
                                final int index,
                                final char character) {
        final Edge activeEdgeToSplit = this.getActiveEdge();
        final Edge splittedEdge = new Edge(activeEdgeToSplit.getFrom(),
                activeEdgeToSplit.getFrom() + this.activeLength,
                nodeToAdd);
        nodeToAdd.getEdges().put(word.charAt(activeEdgeToSplit.getFrom() + this.activeLength),
                new Edge(activeEdgeToSplit.getFrom() + this.activeLength,
                        activeEdgeToSplit.getTo(),
                        activeEdgeToSplit.getNext()));
        nodeToAdd.getEdges().put(character, new Edge(index, word.length(), null));
        this.activeNode.getEdges().put(this.activeEdgeFirstCharacter, splittedEdge);
    }

    public Node setSlinkTo(final Node previouslyAddedNodeOrAddedEdgeNode,
                           final Node node) {
        if(previouslyAddedNodeOrAddedEdgeNode != null) {
            previouslyAddedNodeOrAddedEdgeNode.setSlink(node);
        }
        return node;
    }

    public Node setSlinkToActiveNode(final Node previouslyAddedNodeOrAddedEdgeNode) {
        return setSlinkTo(previouslyAddedNodeOrAddedEdgeNode, this.activeNode);
    }
  }

  private static int idGenerator;

  private final String word;
  private final Node root;
  private ActivePoint activePoint;
  private int remainder;

  public ST(final String word) {
    this.word = word;
    this.root = new Node(idGenerator++);
    this.activePoint = new ActivePoint(this.root, null, 0);
    this.remainder = 0;
    build();
  }

  private void build() {
    for(int i = 0; i < this.word.length(); i++) {
        add(i, this.word.charAt(i));
    }
  }

  private void add(final int index, final char character) {
    this.remainder++;
    boolean characterFoundInTheTree = false;
    Node previouslyAddedNodeOrAddedEdgeNode = null;
    while(!characterFoundInTheTree && this.remainder > 0) {
        if(this.activePoint.pointsToActiveNode()) {
            if(this.activePoint.activeNodeHasEdgeStartingWith(character)) {
                activeNodeHasEdgeStartingWithCharacter(character, previouslyAddedNodeOrAddedEdgeNode);
                characterFoundInTheTree = true;
            }
            else {
                if(this.activePoint.activeNodeIs(this.root)) {
                    rootNodeHasNotEdgeStartingWithCharacter(index, character);
                }
                else {
                    previouslyAddedNodeOrAddedEdgeNode = internalNodeHasNotEdgeStartingWithCharacter(index,
                            character, previouslyAddedNodeOrAddedEdgeNode);
                }
            }
        }
        else {
            if(this.activePoint.pointsToOnActiveEdge(this.word, character)) {
                activeEdgeHasCharacter();
                characterFoundInTheTree = true;
            }
            else {
                if(this.activePoint.activeNodeIs(this.root)) {
                    previouslyAddedNodeOrAddedEdgeNode = edgeFromRootNodeHasNotCharacter(index,
                            character,
                            previouslyAddedNodeOrAddedEdgeNode);
                }
                else {
                    previouslyAddedNodeOrAddedEdgeNode = edgeFromInternalNodeHasNotCharacter(index,
                            character,
                            previouslyAddedNodeOrAddedEdgeNode);
                }
            }
        }
    }
  }

  private void activeNodeHasEdgeStartingWithCharacter(final char character,
                                                    final Node previouslyAddedNodeOrAddedEdgeNode) {
    this.activePoint.setSlinkToActiveNode(previouslyAddedNodeOrAddedEdgeNode);
    this.activePoint = this.activePoint.moveToEdgeStartingWithAndByOne(character);
    if(this.activePoint.pointsToTheEndOfActiveEdge()) {
        this.activePoint = this.activePoint.moveToNextNodeOfActiveEdge();
    }
  }

  private void rootNodeHasNotEdgeStartingWithCharacter(final int index, final char character) {
    this.activePoint.addEdgeToActiveNode(character, new Edge(index, this.word.length(), null));
    this.activePoint = this.activePoint.moveTo(this.root);
    this.remainder--;
    assert this.remainder == 0;
  }

  private Node internalNodeHasNotEdgeStartingWithCharacter(final int index,
                                                         final char character,
                                                         Node previouslyAddedNodeOrAddedEdgeNode) {
    this.activePoint.addEdgeToActiveNode(character, new Edge(index, this.word.length(), null));
    previouslyAddedNodeOrAddedEdgeNode = this.activePoint.setSlinkToActiveNode(previouslyAddedNodeOrAddedEdgeNode);
    if(this.activePoint.activeNodeHasSlink()) {
        this.activePoint = this.activePoint.moveToSlink();
    }
    else {
        this.activePoint = this.activePoint.moveTo(this.root);
    }
    this.remainder--;
    return previouslyAddedNodeOrAddedEdgeNode;
  }

  private void activeEdgeHasCharacter() {
    this.activePoint = this.activePoint.moveByOneCharacter();
    if(this.activePoint.pointsToTheEndOfActiveEdge()) {
        this.activePoint = this.activePoint.moveToNextNodeOfActiveEdge();
    }
  }

  private Node edgeFromRootNodeHasNotCharacter(final int index,
                                             final char character,
                                             Node previouslyAddedNodeOrAddedEdgeNode) {
    final Node newNode = new Node(idGenerator++);
    this.activePoint.splitActiveEdge(this.word, newNode, index, character);
    previouslyAddedNodeOrAddedEdgeNode = this.activePoint.setSlinkTo(previouslyAddedNodeOrAddedEdgeNode, newNode);
    this.activePoint = this.activePoint.moveToEdgeStartingWithAndByActiveLengthMinusOne(this.root,
            this.word.charAt(index - this.remainder + 2));
    this.activePoint = walkDown(index);
    this.remainder--;
    return previouslyAddedNodeOrAddedEdgeNode;
  }

  private Node edgeFromInternalNodeHasNotCharacter(final int index,
                                                 final char character,
                                                 Node previouslyAddedNodeOrAddedEdgeNode) {
    final Node newNode = new Node(idGenerator++);
    this.activePoint.splitActiveEdge(this.word, newNode, index, character);
    previouslyAddedNodeOrAddedEdgeNode = this.activePoint.setSlinkTo(previouslyAddedNodeOrAddedEdgeNode, newNode);
    if(this.activePoint.activeNodeHasSlink()) {
        this.activePoint = this.activePoint.moveToSlink();
    }
    else {
        this.activePoint = this.activePoint.moveTo(this.root);
    }
    this.activePoint = walkDown(index);
    this.remainder--;
    return previouslyAddedNodeOrAddedEdgeNode;
  }

  private ActivePoint walkDown(final int index) {
    while(!this.activePoint.pointsToActiveNode()
            && (this.activePoint.pointsToTheEndOfActiveEdge() || this.activePoint.pointsAfterTheEndOfActiveEdge())) {
        if(this.activePoint.pointsAfterTheEndOfActiveEdge()) {
            this.activePoint = this.activePoint.moveToNextNodeOfActiveEdge(this.word, index);
        }
        else {
            this.activePoint = this.activePoint.moveToNextNodeOfActiveEdge();
        }
    }
    return this.activePoint;
  }

  public String toString(final String word) {
    return this.root.toString(word);
  }

  public boolean contains(final String suffix) {
    return this.root.contains(this.word, suffix);
  }

  public static void main(final String[] args) {
    final String[] words = {
            "abcabcabc$",
            "abc$",
            "abcabxabcd$",
            "abcabxabda$",
            "abcabxad$",
            "aabaaabb$",
            "aababcabcd$",
            "ababcabcd$",
            "abccba$",
            "mississipi$",
            "abacabadabacabae$",
            "abcabcd$",
            "00132220$"
    };
    Arrays.stream(words).forEach(word -> {
        System.out.println("Building suffix tree for word: " + word);
        final ST suffixTree = new ST(word);
        System.out.println("Suffix tree: " + suffixTree.toString(word));
        for(int i = 0; i < word.length() - 1; i++) {
            assert suffixTree.contains(word.substring(i)) : word.substring(i);
        }
    });
  }
}