public static bool FindRoute(this DSGraph graph, string nodeA, string nodeB)
{
DSQueue <string> queue = new DSQueue <string>();
Dictionary <string, bool> visible = new Dictionary <string, bool>();
queue.Enqueue(nodeA);
while (!queue.IsEmpty())
{
var current = queue.Dequeue().Data;
if (!visible.ContainsKey(current))
{
visible.Add(current, true);
if (current == nodeB)
{
return(true);
}
}
foreach (var item in graph._node[current])
{
if (!visible.ContainsKey(item))
{
queue.Enqueue(item);
}
}
}
return(visible.ContainsKey(nodeB));
}
public List <string> BFS(string node)
{
DSQueue <string> dSQueue = new DSQueue <string>();
Dictionary <string, bool> visited = new Dictionary <string, bool>();
dSQueue.Enqueue(node);
while (!dSQueue.IsEmpty())
{
string current = dSQueue.Dequeue().Data;
if (!visited.ContainsKey(current))
{
visited.Add(current, true);
}
foreach (var item in _node[current])
{
if (!visited.ContainsKey(item))
{
dSQueue.Enqueue(item);
}
}
}
return(visited.Select(s => s.Key).ToList());
}
public List <T> LevelOrderTraversalUsingQueue()
{
var newList = new List <T>();
if (this.Head != null)
{
DSQueue <DSTreeNode <T> > queue = new DSQueue <DSTreeNode <T> >();
queue.Enqueue(this.Head);
this.traverseUsingQueue(this.Head, queue, newList);
}
return(newList);
}
public DSTreeNode <int> Construct()
{
if (_listHead == null)
{
return(null);
}
DSQueue <DSTreeNode <int> > queue = new DSQueue <DSTreeNode <int> >();
DSTreeNode <int> treeNode = new DSTreeNode <int>(_listHead.Data);
queue.Enqueue(treeNode);
var current = _listHead;
while (current != null)
{
DSTreeNode <int> de = null;
if (queue.Count > 0)
{
de = queue.Dequeue();
}
if (current.Next != null)
{
de.Left = new DSTreeNode <int>(current.Next.Data);
queue.Enqueue(de.Left);
current = current.Next;
if (current.Next != null)
{
de.Right = new DSTreeNode <int>(current.Next.Data);
queue.Enqueue(de.Right);
current = current.Next;
}
}
else
{
break;
}
}
return(treeNode);
}
public void Add(T value)
{
/// check if we have root?
/// if not then add new root element and then return.
/// If yes then traverse its children from left to right. find first free spot and add the node in that spot.
DSTreeNode <T> newNode = new DSTreeNode <T>(value);
if (this.Head == null)
{
this.Head = newNode;
return;
}
DSQueue <DSTreeNode <T> > dSQueue = new DSQueue <DSTreeNode <T> >();
dSQueue.Enqueue(this.Head);
while (dSQueue.Count > 0)
{
var current = dSQueue.Dequeue();
if (current.Data.Left == null)
{
current.Data.Left = newNode;
break;
}
else
{
dSQueue.Enqueue(current.Data.Left);
}
if (current.Data.Right == null)
{
current.Data.Right = newNode;
break;
}
else
{
dSQueue.Enqueue(current.Data.Right);
}
}
}
private void traverseUsingQueue(DSTreeNode <T> node, DSQueue <DSTreeNode <T> > queue, List <T> newList)
{
while (queue.Count != 0)
{
var current = queue.Dequeue();
newList.Add(current.Data.Data);
if (current.Data.Left != null)
{
queue.Enqueue(current.Data.Left);
}
if (current.Data.Right != null)
{
queue.Enqueue(current.Data.Right);
}
}
}
public int[] LevelOrderTraversal()
{
DSTreeNode <int> _treeHead = Construct();
List <int> arr = new List <int>();
DSQueue <DSTreeNode <int> > queue = new DSQueue <DSTreeNode <int> >();
var tempNode = _treeHead;
while (tempNode != null)
{
arr.Add(tempNode.Data);
if (tempNode.Left != null)
{
queue.Enqueue(tempNode.Left);
}
if (tempNode.Right != null)
{
queue.Enqueue(tempNode.Right);
}
if (queue.Count > 0)
{
tempNode = queue.Dequeue();
}
else
{
tempNode = null;
}
}
return(arr.ToArray());
}
