Exemple #1
0
 public Suffix(Suffix suffix)
 {
     this.originNode = suffix.originNode;
      this.indexOfFirstCharacter = suffix.indexOfFirstCharacter;
      this.indexOfLastCharacter = suffix.indexOfLastCharacter;
      //this.theString = suffix.theString;
      //this.edges = suffix.edges;
 }
        private void AddPrefix(Suffix active, int indexOfLastCharacter)
        {
            int parentNode;
             int lastParentNode = -1;

             for (;;)
             {
            Edge edge;
            parentNode = active.originNode;

            if (active.IsExplicit)
            {
               edge = Edge.Find(theString, Edges, active.originNode, theString[indexOfLastCharacter]);
               if (edge.startNode != -1)
               {
                  break;
               }
            }
            else
            {
               edge = Edge.Find(theString, Edges, active.originNode, theString[active.indexOfFirstCharacter]);
               int span = active.indexOfLastCharacter - active.indexOfFirstCharacter;
               if (theString[edge.indexOfFirstCharacter + span + 1] == theString[indexOfLastCharacter])
               {
                  break;
               }
               parentNode = edge.SplitEdge(active, theString, Edges, Nodes);
            }

            Edge newEdge = new Edge(theString, indexOfLastCharacter, theString.Count, parentNode);
            newEdge.Insert(theString, Edges, Nodes);
            if (lastParentNode > 0)
            {
               Nodes[lastParentNode].suffixNode = parentNode;
            }
            lastParentNode = parentNode;

            if (active.originNode == 0)
            {
               active.indexOfFirstCharacter++;
            }
            else
            {
               active.originNode = Nodes[active.originNode].suffixNode;
            }
            active.Canonize(theString, Edges);
             }
             if (lastParentNode > 0)
             {
            Nodes[lastParentNode].suffixNode = parentNode;
             }
             active.indexOfLastCharacter++;
             active.Canonize(theString, Edges);
        }
 public void BuildTree()
 {
     Node.Count = 1;
      Suffix active = new Suffix(theString, Edges, 0, 0, -1);
      for (int i = 0; i < theString.Count; i++)
      {
     AddPrefix(active, i);
      }
      buildNodes();
 }
Exemple #4
0
        public int SplitEdge(Suffix s, List<int> theString, Dictionary<int, Edge> edges, Dictionary<int, Node> nodes)
        {
            Remove(theString, edges);
             Edge newEdge = new Edge(theString,
                                 this.indexOfFirstCharacter,
                                 this.indexOfFirstCharacter + s.indexOfLastCharacter - s.indexOfFirstCharacter,
                                 s.originNode);
             newEdge.Insert(theString, edges, nodes);

             if (nodes.ContainsKey(newEdge.endNode))
             {
            nodes[newEdge.endNode].suffixNode = s.originNode;
             }
             else
             {
            Node newNode = new Node();
            newNode.suffixNode = s.originNode;
            nodes.Add(newEdge.endNode, newNode);
             }

             this.indexOfFirstCharacter += s.indexOfLastCharacter - s.indexOfFirstCharacter + 1;
             this.startNode = newEdge.endNode;
             this.Insert(theString, edges, nodes);
             return newEdge.endNode;
        }