private void AddNew(List <RelatedNode> nodes, RelatedNode node)
{
if (!nodes.Contains(node))
{
nodes.Add(node);
}
}
public Boolean EqualByOutput(RelatedNode otherNode)
{
if (otherNode == null)
{
return(false);
}
if (nextNodes.Count != otherNode.nextNodes.Count)
{
return(false);
}
var nextNodesCurrentNode = GetNextNodes().OrderBy(el => el.Id);
var nextNodesOtherNode = otherNode.GetNextNodes().OrderBy(el => el.Id);
for (Int32 index = 0; index < nextNodes.Count; index++)
{
var nextNodeCurrentNode = nextNodesCurrentNode.ElementAt(index);
var nextNodeOtherNode = nextNodesOtherNode.ElementAt(index);
if (nextNodeCurrentNode.Id != nextNodeOtherNode.Id)
{
return(false);
}
var firstSymbols = GetIntersectSymbolsWithNext(nextNodeCurrentNode);
var secondSymbols = otherNode.GetIntersectSymbolsWithNext(nextNodeOtherNode);
if (firstSymbols.Count() != secondSymbols.Count())
{
return(false);
}
if (firstSymbols.Union(secondSymbols).Count() != firstSymbols.Count())
{
return(false);
}
}
return(true);
}
private RelatedNode CreateNode()
{
var newNode = new RelatedNode(allNodes.Count);
allNodes.Add(newNode);
return(newNode);
}
private Boolean ExistPathToNext(RelatedNode currentNode, Char symbol)
{
var node = currentNode.GetRelatedNodeByOutput(symbol);
if (node == null)
{
return(false);
}
currentNode = node;
return(true);
}
private Boolean TryRelateWithExistPathToEnd(RelatedNode currentNode, String word)
{
foreach (var startNode in GetStartNodesArriveToEnd(word.Length))
{
if (startNode.ExistPathToEnd(word))
{
currentNode.RelateWithNext(startNode, word.First());
return(true);
}
}
return(false);
}
private void MergeNextNodes(RelatedNode mergeNode)
{
foreach (var node in mergeNode.nextNodes)
{
var symbols = node.GetIntersectSymbolsWithPrevious(mergeNode);
foreach (var symbol in symbols)
{
node.RelateWithPrevious(this, symbol);
}
node.previousNodes.Remove(mergeNode);
}
mergeNode.nextNodes.Clear();
}
public Boolean ExistPathToEnd(String symbols)
{
RelatedNode current = this;
foreach (var symbol in symbols)
{
current = current.nextNodes.FirstOrDefault(el =>
current.GetIntersectSymbolsWithNext(el).Contains(symbol));
if (current == null)
{
return(false);
}
}
return(current.IsEnd());
}
public void AddBranch(String word)
{
RelatedNode currentNode = startNode;
foreach (var symbol in word)
{
var nextNode = currentNode.GetRelatedNodeByOutput(symbol);
if (nextNode == null)
{
nextNode = CreateNode();
currentNode.RelateWithNext(nextNode, symbol);
}
currentNode = nextNode;
}
}
public void Merge(RelatedNode mergeNode)
{
MergePreviousNodes(mergeNode);
MergeNextNodes(mergeNode);
}
public void RelateWithPrevious(RelatedNode previousNode, Char relatedSymbol)
{
AddPrevious(previousNode, relatedSymbol);
previousNode.AddNext(this, relatedSymbol);
}
private void AddPrevious(RelatedNode previousNode, Char relatedSymbol)
{
AddNew(previousNodes, previousNode);
AddInputSymbol(relatedSymbol);
}
private void AddNext(RelatedNode nextNode, Char relatedSymbol)
{
AddNew(nextNodes, nextNode);
AddOutputSymbol(relatedSymbol);
}
public void RelateWithNext(RelatedNode nextNode, Char relatedSymbol)
{
AddNext(nextNode, relatedSymbol);
nextNode.AddPrevious(this, relatedSymbol);
}
public Tree()
{
allNodes = new List <RelatedNode>();
startNode = CreateNode();
}
