//Itterative DFS traversa
public void TraverseDFSWithStack()
{
//Set Stack Last in Last Out
Stack <TreeNode <T> > stack = new Stack <TreeNode <T> >();
//Put Root
stack.Push(this.root);
while (stack.Count > 0)
{
//Remove Last element that was added. First Cycle this means root;
TreeNode <T> currentNode = stack.Pop();
//Returnt/Write Result
Console.Write("{0} ", currentNode.Value);
//Add all children
for (int i = 0; i < currentNode.ChildrenCount; i++)
{
TreeNode <T> childNode = currentNode.GetChild(i);
stack.Push(childNode);
}
//First Cycle - Last element added (the one that is poped) is root. It is displayed. All its children are added to the stack.
//Second Cycle - Last element added is the last child of root. It is displayed and all its children are added.
//Trid cycl - Last element added is the previously pooped element(last child of the last child of root) and so on. Untill stack is empty.
}
}
public void TraverseDFSWithStack()
{
Stack <TreeNode <T> > stack = new Stack <TreeNode <T> >();
stack.Push(this.root);
while (stack.Count > 0)
{
TreeNode <T> currentNode = stack.Pop();
Console.Write("{0} ", currentNode.Value);
for (int i = 0; i < currentNode.ChildrenCount; i++)
{
TreeNode <T> childNode = currentNode.GetChild(i);
stack.Push(childNode);
}
}
}
public void TraverseBFS()
{
Queue <TreeNode <T> > queue = new Queue <TreeNode <T> >();
queue.Enqueue(this.root);
while (queue.Count > 0)
{
TreeNode <T> currentNode = queue.Dequeue();
Console.Write("{0} ", currentNode.Value);
for (int i = 0; i < currentNode.ChildrenCount; i++)
{
TreeNode <T> childNode = currentNode.GetChild(i);
queue.Enqueue(childNode);
}
}
}
private void PrintDFS(TreeNode <T> node, string spaces)
{
if (Root == null)
{
return;
}
Console.WriteLine(spaces + node.Value);
TreeNode <T> child = null;
for (int i = 0; i < node.ChildrenCount; i++)
{
child = node.GetChild(i);
PrintDFS(child, spaces + " ");
}
}
private void TraverseDFS(TreeNode <T> root, string spaces)
{
if (this.root == null)
{
return;
}
Console.WriteLine(spaces + root.Value);
TreeNode <T> child = null;
for (int i = 0; i < root.ChildrenCount; i++)
{
child = root.GetChild(i);
TraverseDFS(child, spaces + " ");
}
}
//recursive dfs
private void TraverseDFS(TreeNode <T> root, string spaces)
{
//bottom comes when method tries to travers the children of a node with no children
if (root == null)
{
return;
}
//writes out values
Console.WriteLine(spaces + root.Value);
//get children, which form subtrees and repeat the algorithm for them
TreeNode <T> child = null;
for (int i = 0; i < root.ChildrenCount; i++)
{
child = root.GetChild(i);
this.TraverseDFS(child, spaces + " ");
}
//when algorithm is reaped for all children then this subtree is traverse
//So when we get to a node with no children the method will simply return, go up one step and continues with the next child
}
//BFS with a queue
public void TraverseBFS()
{
//set up queue, First in First Out
Queue <TreeNode <T> > queue = new Queue <TreeNode <T> >();
//Add the root
queue.Enqueue(this.root);
while (queue.Count > 0)
{
//Detach the node in first position, which for first cycle is the root
TreeNode <T> currentNode = queue.Dequeue();
//Write value
Console.Write("{0} ", currentNode.Value);
//Add all cildren
for (int i = 0; i < currentNode.ChildrenCount; i++)
{
TreeNode <T> childNode = currentNode.GetChild(i);
queue.Enqueue(childNode);
}
//In the next cycle the first child will be teh first element. All its children will be added.
//Third cycle second child will be first element and then its children wiil be added to the back of the queue
}
}
