public void FindShortestPath(MyGraph <T> graph, MyGraphNode <T> source, MyGraphNode <T> destination)
{
var previousNodes = new Dictionary <MyGraphNode <T>, MyGraphNode <T> >();
var distances = new Dictionary <MyGraphNode <T>, int>();
DijkstraTraversal(graph, source, destination, previousNodes, distances);
var path = new LinkedLists.MyLinkedList <MyGraphNode <T> >();
var traverse = true;
var dest = destination;
while (traverse)
{
path.AddFirst(dest);
if (dest.Equals(source))
{
traverse = false;
}
dest = previousNodes[dest];
}
var node = path.FirstNode;
while (node != null)
{
Console.WriteLine(node.Object.Data);
node = node.Next;
}
}
public void AddUndirectedEdge(MyGraphNode <T> from, MyGraphNode <T> to, int cost)
{
from.Neighbors.Add(to);
from.Weights.Add(cost);
to.Neighbors.Add(from);
to.Weights.Add(cost);
}
public void AddDirectedEdge(MyGraphNode <T> from, MyNode <T> to, int cost)
{
var toGraphNode = to as MyGraphNode <T>;
if (toGraphNode == null)
{
return;
}
AddDirectedEdge(from, toGraphNode, cost);
}
public void AddUndirectedEdge(MyNode <T> from, MyGraphNode <T> to, int cost)
{
var fromGraphNode = from as MyGraphNode <T>;
if (fromGraphNode == null)
{
return;
}
AddUndirectedEdge(fromGraphNode, to, cost);
}
public void BFTraversal <T>(MyGraphNode <T> root)
{
var queue = new MyQueue <MyGraphNode <T> >();
var visitedSet = new HashSet <MyGraphNode <T> >();
queue.Enqueue(root);
visitedSet.Add(root);
while (!queue.Empty())
{
var vertex = queue.Dequeue();
Console.WriteLine(vertex.Data);
foreach (MyGraphNode <T> node in vertex.Neighbors)
{
if (!visitedSet.Contains(node))
{
visitedSet.Add(node);
queue.Enqueue(node);
}
}
}
}
private static void DijkstraTraversal(MyGraph <T> graph, MyGraphNode <T> source, MyGraphNode <T> destination, Dictionary <MyGraphNode <T>, MyGraphNode <T> > previousNodes, Dictionary <MyGraphNode <T>, int> distances)
{
var heap = new Collection <DijkstraMinHeapNode>();
var positionDict = new Dictionary <DijkstraMinHeapNode, int>();
var nodeMap = CreateMinHeapAndGetDijkstraNodeMap(graph, source, heap, previousNodes, distances, positionDict);
var bottom = graph.NodeCount - 1;
var root = 0;
var visitedSet = new HashSet <MyGraphNode <T> >();
while (root <= bottom)
{
var minHeapNode = heap.ExtractMin(bottom, positionDict);
visitedSet.Add(minHeapNode.Vertex);
bottom--;
if (minHeapNode.Vertex.Equals(destination))
{
break;
}
for (int i = 0; i < minHeapNode.Vertex.Neighbors.Count; i++)
{
if (!visitedSet.Contains(minHeapNode.Vertex.Neighbors[i] as MyGraphNode <T>))
{
var node = minHeapNode.Vertex.Neighbors[i] as MyGraphNode <T>;
if (distances[node] > minHeapNode.Distance + minHeapNode.Vertex.Weights[i])
{
heap[positionDict[nodeMap[node]]].Distance = minHeapNode.Distance + minHeapNode.Vertex.Weights[i];
distances[node] = heap[positionDict[nodeMap[node]]].Distance;
previousNodes[node] = minHeapNode.Vertex;
FixUp(heap, positionDict[nodeMap[node]], positionDict);
}
}
}
}
}
public bool Remove(T data)
{
MyGraphNode <T> reqNode = nodes.FindByData(data) as MyGraphNode <T>;
if (reqNode == null)
{
return(false);
}
nodes.Remove(reqNode);
// Remove all the edges to this node
foreach (MyGraphNode <T> node in nodes)
{
var index = node.Neighbors.IndexOf(reqNode);
if (index != -1)
{
node.Neighbors.RemoveAt(index);
node.Weights.RemoveAt(index);
}
}
return(true);
}
public void DFTraversal <T>(MyGraphNode <T> root)
{
var visitedSet = new HashSet <MyGraphNode <T> >();
var stack = new MyStack <MyGraphNode <T> >();
var vertex = root;
stack.Push(root);
visitedSet.Add(root);
while (!stack.Empty())
{
vertex = stack.Pop();
Console.WriteLine(vertex.Data);
foreach (MyGraphNode <T> node in vertex.Neighbors)
{
if (!visitedSet.Contains(node))
{
visitedSet.Add(node);
stack.Push(node);
}
}
}
}
private static Dictionary <MyGraphNode <T>, DijkstraMinHeapNode> CreateMinHeapAndGetDijkstraNodeMap(MyGraph <T> graph, MyGraphNode <T> source, Collection <DijkstraMinHeapNode> heap, Dictionary <MyGraphNode <T>, MyGraphNode <T> > previousNode, Dictionary <MyGraphNode <T>, int> distances, Dictionary <DijkstraMinHeapNode, int> positionDict)
{
var dijkstraNodeMap = new Dictionary <MyGraphNode <T>, DijkstraMinHeapNode>();
// int.MaxValue is treated as "infinity".
for (int i = 0; i < graph.NodeCount; i++)
{
var node = new DijkstraMinHeapNode(graph.Nodes[i] as MyGraphNode <T>, int.MaxValue);
dijkstraNodeMap[graph.Nodes[i] as MyGraphNode <T> ] = node;
heap.Add(node);
distances[node.Vertex] = int.MaxValue;
positionDict[node] = i;
if (source.Data.Equals(graph.Nodes[i].Data))
{
var temp = heap[0];
var tempPos = positionDict[heap[0]];
heap[0] = heap[i];
positionDict[heap[i]] = positionDict[heap[i]];
heap[i] = temp;
positionDict[heap[i]] = tempPos;
heap[0].Distance = 0;
previousNode[heap[0].Vertex] = heap[0].Vertex;
distances[heap[0].Vertex] = heap[0].Distance;
}
}
return(dijkstraNodeMap);
}
public DijkstraMinHeapNode(MyGraphNode <T> vertex, int distance)
{
Vertex = vertex;
Distance = distance;
}
public void AddNode(MyGraphNode <T> node)
{
nodes.Add(node);
}
