public void DoTest()
{
var V01 = new string[] { "A", "B", "C", "D", "E", "X" };
var DAG01 = new DirectedSparseGraph <string>();
// Insert new values of V
DAG01.AddVertices(V01);
// Insert new value for edges
DAG01.AddEdge("A", "B");
DAG01.AddEdge("A", "X");
DAG01.AddEdge("B", "C");
DAG01.AddEdge("C", "D");
DAG01.AddEdge("D", "E");
DAG01.AddEdge("E", "X");
// PRINT THE GRAPH
// [*] DAG (Directed Asyclic Graph):
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort01 = TopologicalSorter.Sort <string>(DAG01);
var output01 = string.Empty;
foreach (var node in topologicalSort01)
{
output01 = String.Format("{0}({1}) ", output01, node);
}
var V02 = new int[] { 7, 5, 3, 11, 8, 2, 9, 10 };
var DAG02 = new DirectedSparseGraph <int>();
// Insert new values of V
DAG02.AddVertices(V02);
// Insert new value for edges
DAG02.AddEdge(7, 11);
DAG02.AddEdge(7, 8);
DAG02.AddEdge(5, 11);
DAG02.AddEdge(3, 8);
DAG02.AddEdge(3, 10);
DAG02.AddEdge(11, 2);
DAG02.AddEdge(11, 9);
DAG02.AddEdge(11, 10);
DAG02.AddEdge(8, 9);
// PRINT THE GRAPH
// [*] DAG (Directed Asyclic Graph):
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort02 = TopologicalSorter.Sort <int>(DAG02);
var output02 = string.Empty;
foreach (var node in topologicalSort02)
{
output02 = String.Format("{0}({1}) ", output02, node);
}
}
public static void UnitTestD()
{
var graph = new DirectedSparseGraph <Employee>();
var employeeA = new Employee("a", "", 10);
var employeeB = new Employee("b", "a", 10);
var employeeC = new Employee("c", "a", 10);
var employeeD = new Employee("d", "a", 10);
var employeeE = new Employee("e", "b", 10);
var verticesSet1 = new Employee[] { employeeA, employeeB, employeeC, employeeD, employeeE };
graph.AddVertices(verticesSet1);
graph.AddEdge(employeeA, employeeB);
graph.AddEdge(employeeA, employeeC);
graph.AddEdge(employeeA, employeeD);
graph.AddEdge(employeeB, employeeE);
var allEdges = graph.Edges.ToList();
Assert.True(graph.VerticesCount == 5, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 4, "Wrong edges count.");
Assert.True(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Assert.True(graph.OutgoingEdges(employeeA).ToList().Count == 3, "Wrong outgoing edges from 'a'.");
Assert.True(graph.OutgoingEdges(employeeB).ToList().Count == 1, "Wrong outgoing edges from 'b'.");
Assert.True(graph.OutgoingEdges(employeeC).ToList().Count == 0, "Wrong outgoing edges from 'c'.");
Assert.True(graph.OutgoingEdges(employeeD).ToList().Count == 0, "Wrong outgoing edges from 'd'.");
Assert.True(graph.OutgoingEdges(employeeE).ToList().Count == 0, "Wrong outgoing edges from 'e'.");
Assert.True(graph.IncomingEdges(employeeA).ToList().Count == 0, "Wrong incoming edges from 'a'.");
Assert.True(graph.IncomingEdges(employeeB).ToList().Count == 1, "Wrong incoming edges from 'b'.");
Assert.True(graph.IncomingEdges(employeeC).ToList().Count == 1, "Wrong incoming edges from 'c'.");
Assert.True(graph.IncomingEdges(employeeD).ToList().Count == 1, "Wrong incoming edges from 'd'.");
Assert.True(graph.IncomingEdges(employeeE).ToList().Count == 1, "Wrong incoming edges from 'e'.");
var dfsWalk = graph.DepthFirstWalk(employeeA);
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node.Id));
}
graph.Clear();
}
public static void DoTest()
{
var graph = new DirectedSparseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("d", "s");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("c", "d");
graph.AddEdge("v", "f");
graph.AddEdge("f", "c");
var allEdges = graph.Edges.ToList();
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 14, "Wrong edges count.");
Assert.True(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Assert.True(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'.");
Assert.True(graph.OutgoingEdges("s").ToList().Count == 1, "Wrong outgoing edges from 's'.");
Assert.True(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'.");
Assert.True(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'.");
Assert.True(graph.OutgoingEdges("c").ToList().Count == 3, "Wrong outgoing edges from 'c'.");
Assert.True(graph.OutgoingEdges("v").ToList().Count == 1, "Wrong outgoing edges from 'v'.");
Assert.True(graph.OutgoingEdges("f").ToList().Count == 1, "Wrong outgoing edges from 'f'.");
Assert.True(graph.OutgoingEdges("z").ToList().Count == 0, "Wrong outgoing edges from 'z'.");
Assert.True(graph.IncomingEdges("a").ToList().Count == 1, "Wrong incoming edges from 'a'.");
Assert.True(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'.");
Assert.True(graph.IncomingEdges("d").ToList().Count == 2, "Wrong incoming edges from 'd'.");
Assert.True(graph.IncomingEdges("x").ToList().Count == 1, "Wrong incoming edges from 'x'.");
Assert.True(graph.IncomingEdges("c").ToList().Count == 3, "Wrong incoming edges from 'c'.");
Assert.True(graph.IncomingEdges("v").ToList().Count == 1, "Wrong incoming edges from 'v'.");
Assert.True(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'.");
Assert.True(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 11, "Wrong edges count.");
graph.RemoveVertex("x");
Assert.True(graph.VerticesCount == 7, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 7, "Wrong edges count.");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
// BFS from A
// Walk the graph using BFS from A:
var bfsWalk = graph.BreadthFirstWalk("a");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk)
{
Console.Write(String.Format("({0})", node));
}
// DFS from A
// Walk the graph using DFS from A:
var dfsWalk = graph.DepthFirstWalk("a");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
// BFS from F
Console.WriteLine("Walk the graph using BFS from F:");
bfsWalk = graph.BreadthFirstWalk("f");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk)
{
Console.Write(String.Format("({0})", node));
}
// DFS from F
// Walk the graph using DFS from F:
dfsWalk = graph.DepthFirstWalk("f");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
/********************************************************************/
graph.Clear();
// Cleared the graph from all vertices and edges
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Assert.True(graph.VerticesCount == 6, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 8, "Wrong edges count.");
// Walk the graph using DFS:
dfsWalk = graph.DepthFirstWalk();
// output: (a) (b) (e) (d) (c) (f)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
}
public static void DoTest()
{
var graph = new DirectedSparseGraph <Employee>();
var employeeA = new Employee("a", "", 10);
var employeeB = new Employee("b", "a", 10);
var employeeC = new Employee("c", "a", 10);
var employeeD = new Employee("d", "a", 10);
var employeeE = new Employee("e", "b", 10);
var verticesSet1 = new Employee[] { employeeA, employeeB, employeeC, employeeD, employeeE };
graph.AddVertices(verticesSet1);
graph.AddEdge(employeeA, employeeB);
graph.AddEdge(employeeA, employeeC);
graph.AddEdge(employeeA, employeeD);
graph.AddEdge(employeeB, employeeE);
var allEdges = graph.Edges.ToList();
Assert.True(graph.VerticesCount == 5, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 4, "Wrong edges count.");
Assert.True(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Assert.True(graph.OutgoingEdges(employeeA).ToList().Count == 3, "Wrong outgoing edges from 'a'.");
Assert.True(graph.OutgoingEdges(employeeB).ToList().Count == 1, "Wrong outgoing edges from 'b'.");
Assert.True(graph.OutgoingEdges(employeeC).ToList().Count == 0, "Wrong outgoing edges from 'c'.");
Assert.True(graph.OutgoingEdges(employeeD).ToList().Count == 0, "Wrong outgoing edges from 'd'.");
Assert.True(graph.OutgoingEdges(employeeE).ToList().Count == 0, "Wrong outgoing edges from 'e'.");
Assert.True(graph.IncomingEdges(employeeA).ToList().Count == 0, "Wrong incoming edges from 'a'.");
Assert.True(graph.IncomingEdges(employeeB).ToList().Count == 1, "Wrong incoming edges from 'b'.");
Assert.True(graph.IncomingEdges(employeeC).ToList().Count == 1, "Wrong incoming edges from 'c'.");
Assert.True(graph.IncomingEdges(employeeD).ToList().Count == 1, "Wrong incoming edges from 'd'.");
Assert.True(graph.IncomingEdges(employeeE).ToList().Count == 1, "Wrong incoming edges from 'e'.");
// DFS from A
// Walk the graph using DFS from A:
var dfsWalk = graph.DepthFirstWalk(employeeA);
// output: (s) (a) (x) (z) (d) (c) (f) (v)
// foreach (var node in dfsWalk)
// {
// Console.Write(String.Format("({0})", node));
// }
// DFS from F
// Walk the graph using DFS from F:
//dfsWalk = graph.DepthFirstWalk(employeeB);
// output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node.Id));
}
/********************************************************************/
graph.Clear();
}
public static void DoTest()
{
string[] V;
DirectedSparseGraph <string> DAG;
UndirectedSparseGraph <string> CyclicGraph;
DirectedSparseGraph <string> DigraphWithCycles;
// Init graph object
DigraphWithCycles = new DirectedSparseGraph <string>();
// Init V
V = new string[6] {
"r", "s", "t", "x", "y", "z"
};
// Insert V
DigraphWithCycles.AddVertices(V);
// Insert E
DigraphWithCycles.AddEdge("r", "s");
DigraphWithCycles.AddEdge("r", "t");
DigraphWithCycles.AddEdge("s", "t");
DigraphWithCycles.AddEdge("s", "x");
DigraphWithCycles.AddEdge("t", "x");
DigraphWithCycles.AddEdge("t", "y");
DigraphWithCycles.AddEdge("t", "z");
DigraphWithCycles.AddEdge("x", "y");
DigraphWithCycles.AddEdge("x", "z");
DigraphWithCycles.AddEdge("y", "z");
DigraphWithCycles.AddEdge("z", "r");
DigraphWithCycles.AddEdge("z", "s");
var isCyclic = CyclesDetector.IsCyclic(DigraphWithCycles);
Debug.Assert(isCyclic, "Wrong status! The graph has cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] Directed Graph:");
Console.WriteLine(DigraphWithCycles.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.WriteLine("\r\n*********************************************\r\n");
/***************************************************************************************/
CyclicGraph = new UndirectedSparseGraph <string>();
V = new[] { "A", "B", "C", "D", "E" };
// Insert new values of V
CyclicGraph.AddVertices(V);
// Insert new value for edges
CyclicGraph.AddEdge("A", "C");
CyclicGraph.AddEdge("B", "A");
CyclicGraph.AddEdge("B", "C");
CyclicGraph.AddEdge("C", "E");
CyclicGraph.AddEdge("C", "D");
CyclicGraph.AddEdge("D", "B");
CyclicGraph.AddEdge("E", "D");
isCyclic = CyclesDetector.IsCyclic(CyclicGraph);
Debug.Assert(isCyclic, "Wrong status! The graph has cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] Undirected Graph:");
Console.WriteLine(CyclicGraph.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.WriteLine("\r\n*********************************************\r\n");
/***************************************************************************************/
DAG = new DirectedSparseGraph <string>();
V = new[] { "A", "B", "C", "D", "E", "X" };
// Insert new values of V
DAG.AddVertices(V);
// Insert new value for edges
DAG.AddEdge("A", "B");
DAG.AddEdge("A", "X");
DAG.AddEdge("B", "C");
DAG.AddEdge("C", "D");
DAG.AddEdge("D", "E");
DAG.AddEdge("E", "X");
isCyclic = CyclesDetector.IsCyclic(DAG);
Debug.Assert(isCyclic == false, "Wrong status! The graph has no cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.ReadLine();
}
public static void DoTest()
{
var graph = new DirectedSparseGraph<string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("d", "s");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("c", "d");
graph.AddEdge("v", "f");
graph.AddEdge("f", "c");
var allEdges = graph.Edges.ToList();
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 14, "Wrong edges count.");
Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'.");
Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 1, "Wrong outgoing edges from 's'.");
Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'.");
Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'.");
Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 3, "Wrong outgoing edges from 'c'.");
Debug.Assert(graph.OutgoingEdges("v").ToList().Count == 1, "Wrong outgoing edges from 'v'.");
Debug.Assert(graph.OutgoingEdges("f").ToList().Count == 1, "Wrong outgoing edges from 'f'.");
Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 0, "Wrong outgoing edges from 'z'.");
Debug.Assert(graph.IncomingEdges("a").ToList().Count == 1, "Wrong incoming edges from 'a'.");
Debug.Assert(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'.");
Debug.Assert(graph.IncomingEdges("d").ToList().Count == 2, "Wrong incoming edges from 'd'.");
Debug.Assert(graph.IncomingEdges("x").ToList().Count == 1, "Wrong incoming edges from 'x'.");
Debug.Assert(graph.IncomingEdges("c").ToList().Count == 3, "Wrong incoming edges from 'c'.");
Debug.Assert(graph.IncomingEdges("v").ToList().Count == 1, "Wrong incoming edges from 'v'.");
Debug.Assert(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'.");
Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
Console.WriteLine("[*] Directed Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 11, "Wrong edges count.");
Console.WriteLine("After removing edges (d-c), (c-v), (a-z):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveVertex("x");
Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 7, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
Console.WriteLine("Re-added the deleted vertices and edges to the graph.");
Console.WriteLine(graph.ToReadable() + "\r\n");
// BFS from A
Console.WriteLine("Walk the graph using BFS from A:");
var bfsWalk = graph.BreadthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk) Console.Write(String.Format("({0})", node));
Console.WriteLine("\r\n");
// DFS from A
Console.WriteLine("Walk the graph using DFS from A:");
var dfsWalk = graph.DepthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node));
Console.WriteLine("\r\n");
// BFS from F
Console.WriteLine("Walk the graph using BFS from F:");
bfsWalk = graph.BreadthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk) Console.Write(String.Format("({0})", node));
Console.WriteLine("\r\n");
// DFS from F
Console.WriteLine("Walk the graph using DFS from F:");
dfsWalk = graph.DepthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node));
Console.WriteLine("\r\n");
Console.ReadLine();
/********************************************************************/
graph.Clear();
Console.WriteLine("Cleared the graph from all vertices and edges.\r\n");
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Directed Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using DFS:");
dfsWalk = graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f)
foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node));
Console.ReadLine();
}
public static void DoTest()
{
var V01 = new string[] { "A", "B", "C", "D", "E", "X" };
var DAG01 = new DirectedSparseGraph <string>();
// Insert new values of V
DAG01.AddVertices(V01);
// Insert new value for edges
DAG01.AddEdge("A", "B");
DAG01.AddEdge("A", "X");
DAG01.AddEdge("B", "C");
DAG01.AddEdge("C", "D");
DAG01.AddEdge("D", "E");
DAG01.AddEdge("E", "X");
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG01.ToReadable() + "\r\n");
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort01 = TopologicalSorter.Sort <string>(DAG01);
var output01 = string.Empty;
foreach (var node in topologicalSort01)
{
output01 = String.Format("{0}({1}) ", output01, node);
}
// PRINT THE TOPOLOGICAL SORT
Console.WriteLine("Was the previous graph cyclic? " + output01);
Console.WriteLine("\r\n*********************************************\r\n");
/**************************************************************************/
var V02 = new int[] { 7, 5, 3, 11, 8, 2, 9, 10 };
var DAG02 = new DirectedSparseGraph <int>();
// Insert new values of V
DAG02.AddVertices(V02);
// Insert new value for edges
DAG02.AddEdge(7, 11);
DAG02.AddEdge(7, 8);
DAG02.AddEdge(5, 11);
DAG02.AddEdge(3, 8);
DAG02.AddEdge(3, 10);
DAG02.AddEdge(11, 2);
DAG02.AddEdge(11, 9);
DAG02.AddEdge(11, 10);
DAG02.AddEdge(8, 9);
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG02.ToReadable() + "\r\n");
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort02 = TopologicalSorter.Sort <int>(DAG02);
var output02 = string.Empty;
foreach (var node in topologicalSort02)
{
output02 = String.Format("{0}({1}) ", output02, node);
}
// PRINT THE TOPOLOGICAL SORT
Console.WriteLine("Was the previous graph cyclic? " + output02);
Console.WriteLine("\r\n*********************************************\r\n");
Console.ReadLine();
}
public static void DoTest()
{
string[] V;
DirectedSparseGraph<string> DAG;
UndirectedSparseGraph<string> CyclicGraph;
DirectedSparseGraph<string> DigraphWithCycles;
// Init graph object
DigraphWithCycles = new DirectedSparseGraph<string>();
// Init V
V = new string[6] { "r", "s", "t", "x", "y", "z" };
// Insert V
DigraphWithCycles.AddVertices(V);
// Insert E
DigraphWithCycles.AddEdge("r", "s");
DigraphWithCycles.AddEdge("r", "t");
DigraphWithCycles.AddEdge("s", "t");
DigraphWithCycles.AddEdge("s", "x");
DigraphWithCycles.AddEdge("t", "x");
DigraphWithCycles.AddEdge("t", "y");
DigraphWithCycles.AddEdge("t", "z");
DigraphWithCycles.AddEdge("x", "y");
DigraphWithCycles.AddEdge("x", "z");
DigraphWithCycles.AddEdge("y", "z");
DigraphWithCycles.AddEdge("z", "r");
DigraphWithCycles.AddEdge("z", "s");
var isCyclic = CyclesDetector.IsCyclic<string>(DigraphWithCycles);
Debug.Assert(isCyclic == true, "Wrong status! The graph has cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] Directed Graph:");
Console.WriteLine(DigraphWithCycles.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.WriteLine("\r\n*********************************************\r\n");
/***************************************************************************************/
CyclicGraph = new UndirectedSparseGraph<string>();
V = new string[] { "A", "B", "C", "D", "E" };
// Insert new values of V
CyclicGraph.AddVertices(V);
// Insert new value for edges
CyclicGraph.AddEdge("A", "C");
CyclicGraph.AddEdge("B", "A");
CyclicGraph.AddEdge("B", "C");
CyclicGraph.AddEdge("C", "E");
CyclicGraph.AddEdge("C", "D");
CyclicGraph.AddEdge("D", "B");
CyclicGraph.AddEdge("E", "D");
isCyclic = CyclesDetector.IsCyclic<string>(CyclicGraph);
Debug.Assert(isCyclic == true, "Wrong status! The graph has cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] Undirected Graph:");
Console.WriteLine(CyclicGraph.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.WriteLine("\r\n*********************************************\r\n");
/***************************************************************************************/
DAG = new DirectedSparseGraph<string>();
V = new string[] { "A", "B", "C", "D", "E", "X" };
// Insert new values of V
DAG.AddVertices(V);
// Insert new value for edges
DAG.AddEdge("A", "B");
DAG.AddEdge("A", "X");
DAG.AddEdge("B", "C");
DAG.AddEdge("C", "D");
DAG.AddEdge("D", "E");
DAG.AddEdge("E", "X");
isCyclic = CyclesDetector.IsCyclic<string>(DAG);
Debug.Assert(isCyclic == false, "Wrong status! The graph has no cycles.");
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG.ToReadable() + "\r\n");
Console.WriteLine("Was the previous graph cyclic? " + isCyclic);
Console.ReadLine();
}
public static void DoTest()
{
var graph = new DirectedSparseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("d", "s");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("c", "d");
graph.AddEdge("v", "f");
graph.AddEdge("f", "c");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 14, "Wrong edges count.");
Console.WriteLine("[*] Directed Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 11, "Wrong edges count.");
Console.WriteLine("After removing edges (d-c), (c-v), (a-z):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveVertex("x");
Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 7, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "a");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
Console.WriteLine("Re-added the deleted vertices and edges to the graph.");
Console.WriteLine(graph.ToReadable() + "\r\n");
// BFS from A
Console.WriteLine("Walk the graph using BFS from A:");
var bfsWalk = graph.BreadthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk)
{
Console.Write(String.Format("({0})", node));
}
Console.WriteLine("\r\n");
// DFS from A
Console.WriteLine("Walk the graph using DFS from A:");
var dfsWalk = graph.DepthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
Console.WriteLine("\r\n");
// BFS from F
Console.WriteLine("Walk the graph using BFS from F:");
bfsWalk = graph.BreadthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in bfsWalk)
{
Console.Write(String.Format("({0})", node));
}
Console.WriteLine("\r\n");
// DFS from F
Console.WriteLine("Walk the graph using DFS from F:");
dfsWalk = graph.DepthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
Console.WriteLine("\r\n");
Console.ReadLine();
/********************************************************************/
graph.Clear();
Console.WriteLine("Cleared the graph from all vertices and edges.\r\n");
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Directed Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using DFS:");
dfsWalk = graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f)
foreach (var node in dfsWalk)
{
Console.Write(String.Format("({0})", node));
}
Console.ReadLine();
}
// GET: /<controller>/
public IActionResult Index()
{
string[] V;
DirectedSparseGraph <string> DAG;
//UndirectedSparseGraph<string> CyclicGraph;
DirectedSparseGraph <string> DigraphWithCycles;
// Init graph object
DigraphWithCycles = new DirectedSparseGraph <string>();
// Init V
V = new string[6] {
"r", "s", "t", "x", "y", "z"
};
result = result + "Vertices: " + "'r', 's', 't', 'x', 'y', 'z'" + "\n";
// Insert V
DigraphWithCycles.AddVertices(V);
// Insert E
DigraphWithCycles.AddEdge("r", "s");
DigraphWithCycles.AddEdge("r", "t");
DigraphWithCycles.AddEdge("s", "t");
DigraphWithCycles.AddEdge("s", "x");
DigraphWithCycles.AddEdge("t", "x");
DigraphWithCycles.AddEdge("t", "y");
DigraphWithCycles.AddEdge("t", "z");
DigraphWithCycles.AddEdge("x", "y");
DigraphWithCycles.AddEdge("x", "z");
DigraphWithCycles.AddEdge("y", "z");
DigraphWithCycles.AddEdge("z", "r");
DigraphWithCycles.AddEdge("z", "s");
var isCyclic = CyclesDetector.IsCyclic <string>(DigraphWithCycles);
// PRINT THE GRAPH
result = result + "[*] Directed Graph:";
result = result + DigraphWithCycles.ToReadable() + "\r\n";
result = result + "Is directed graph above cyclic? " + "=> answer is " + isCyclic + "\n\n";
///***************************************************************************************/
//CyclicGraph = new UndirectedSparseGraph<string>();
//V = new string[] { "A", "B", "C", "D", "E" };
//result = result + "Vertices: " + "'A', 'B', 'C', 'D', 'E'" + "\n";
//// Insert new values of V
//CyclicGraph.AddVertices(V);
//// Insert new value for edges
//CyclicGraph.AddEdge("A", "C");
//CyclicGraph.AddEdge("B", "A");
//CyclicGraph.AddEdge("B", "C");
//CyclicGraph.AddEdge("C", "E");
//CyclicGraph.AddEdge("C", "D");
//CyclicGraph.AddEdge("D", "B");
//CyclicGraph.AddEdge("E", "D");
//isCyclic = CyclesDetector.IsCyclic<string>(CyclicGraph);
//// PRINT THE GRAPH
//result = result + "[*] Undirected Graph:";
//result = result + CyclicGraph.ToReadable() + "\r\n";
//result = result + "Is un-directed graph above cyclic? " + "=> answer is " + isCyclic;
//Console.WriteLine("\r\n*********************************************\r\n");
///***************************************************************************************/
DAG = new DirectedSparseGraph <string>();
V = new string[] { "A", "B", "C", "D", "E", "X" };
result = result + "Vertices: " + "'A', 'B', 'C', 'D', 'E', 'X'" + "\n";
// Insert new values of V
DAG.AddVertices(V);
// Insert new value for edges
DAG.AddEdge("A", "B");
DAG.AddEdge("A", "X");
DAG.AddEdge("B", "C");
DAG.AddEdge("C", "D");
DAG.AddEdge("D", "E");
DAG.AddEdge("E", "X");
isCyclic = CyclesDetector.IsCyclic <string>(DAG);
//Debug.Assert(isCyclic == false, "Wrong status! The graph has no cycles.");
// PRINT THE GRAPH
result = result + "[*] DAG(Directed Asyclic Graph): ";
result = result + DAG.ToReadable() + "\r\n";
result = result + "Is directed graph above cyclic? " + "=> answer is " + isCyclic;
HtmlString html = StringHelper.GetHtmlString(result);
return(View(html));
}
public static void DoTest()
{
string[] V;
DirectedSparseGraph <string> DAG;
UndirectedSparseGraph <string> CyclicGraph;
DirectedSparseGraph <string> DigraphWithCycles;
// Init graph object
DigraphWithCycles = new DirectedSparseGraph <string>();
// Init V
V = new string[6] {
"r", "s", "t", "x", "y", "z"
};
// Insert V
DigraphWithCycles.AddVertices(V);
// Insert E
DigraphWithCycles.AddEdge("r", "s");
DigraphWithCycles.AddEdge("r", "t");
DigraphWithCycles.AddEdge("s", "t");
DigraphWithCycles.AddEdge("s", "x");
DigraphWithCycles.AddEdge("t", "x");
DigraphWithCycles.AddEdge("t", "y");
DigraphWithCycles.AddEdge("t", "z");
DigraphWithCycles.AddEdge("x", "y");
DigraphWithCycles.AddEdge("x", "z");
DigraphWithCycles.AddEdge("y", "z");
DigraphWithCycles.AddEdge("z", "r");
DigraphWithCycles.AddEdge("z", "s");
var isCyclic = CyclesDetector.IsCyclic <string>(DigraphWithCycles);
Assert.True(isCyclic == true, "Wrong status! The graph has cycles.");
CyclicGraph = new UndirectedSparseGraph <string>();
V = new string[] { "A", "B", "C", "D", "E" };
// Insert new values of V
CyclicGraph.AddVertices(V);
// Insert new value for edges
CyclicGraph.AddEdge("A", "C");
CyclicGraph.AddEdge("B", "A");
CyclicGraph.AddEdge("B", "C");
CyclicGraph.AddEdge("C", "E");
CyclicGraph.AddEdge("C", "D");
CyclicGraph.AddEdge("D", "B");
CyclicGraph.AddEdge("E", "D");
isCyclic = CyclesDetector.IsCyclic <string>(CyclicGraph);
Assert.True(isCyclic == true, "Wrong status! The graph has cycles.");
DAG = new DirectedSparseGraph <string>();
V = new string[] { "A", "B", "C", "D", "E", "X" };
// Insert new values of V
DAG.AddVertices(V);
// Insert new value for edges
DAG.AddEdge("A", "B");
DAG.AddEdge("A", "X");
DAG.AddEdge("B", "C");
DAG.AddEdge("C", "D");
DAG.AddEdge("D", "E");
DAG.AddEdge("E", "X");
isCyclic = CyclesDetector.IsCyclic <string>(DAG);
Assert.True(isCyclic == false, "Wrong status! The graph has no cycles.");
}
public static void DoTest()
{
// Init graph object
var digraphWithCycles = new DirectedSparseGraph <string>();
// Init V
var v = new string[6] {
"r", "s", "t", "x", "y", "z"
};
// Insert V
digraphWithCycles.AddVertices(v);
// Insert E
digraphWithCycles.AddEdge("r", "s");
digraphWithCycles.AddEdge("r", "t");
digraphWithCycles.AddEdge("s", "t");
digraphWithCycles.AddEdge("s", "x");
digraphWithCycles.AddEdge("t", "x");
digraphWithCycles.AddEdge("t", "y");
digraphWithCycles.AddEdge("t", "z");
digraphWithCycles.AddEdge("x", "y");
digraphWithCycles.AddEdge("x", "z");
digraphWithCycles.AddEdge("y", "z");
digraphWithCycles.AddEdge("z", "r");
digraphWithCycles.AddEdge("z", "s");
var isCyclic = CyclesDetector.IsCyclic <string>(digraphWithCycles);
Assert.True(isCyclic == true, "Wrong status! The graph has cycles.");
var cyclicGraph = new UndirectedSparseGraph <string>();
v = new string[] { "A", "B", "C", "D", "E" };
// Insert new values of V
cyclicGraph.AddVertices(v);
// Insert new value for edges
cyclicGraph.AddEdge("A", "C");
cyclicGraph.AddEdge("B", "A");
cyclicGraph.AddEdge("B", "C");
cyclicGraph.AddEdge("C", "E");
cyclicGraph.AddEdge("C", "D");
cyclicGraph.AddEdge("D", "B");
cyclicGraph.AddEdge("E", "D");
isCyclic = CyclesDetector.IsCyclic <string>(cyclicGraph);
Assert.True(isCyclic == true, "Wrong status! The graph has cycles.");
var dag = new DirectedSparseGraph <string>();
v = new string[] { "A", "B", "C", "D", "E", "X" };
// Insert new values of V
dag.AddVertices(v);
// Insert new value for edges
dag.AddEdge("A", "B");
dag.AddEdge("A", "X");
dag.AddEdge("B", "C");
dag.AddEdge("C", "D");
dag.AddEdge("D", "E");
dag.AddEdge("E", "X");
isCyclic = CyclesDetector.IsCyclic <string>(dag);
Assert.True(isCyclic == false, "Wrong status! The graph has no cycles.");
}
public static void DoTest()
{
var V01 = new string[] { "A", "B", "C", "D", "E", "X" };
var DAG01 = new DirectedSparseGraph<string>();
// Insert new values of V
DAG01.AddVertices(V01);
// Insert new value for edges
DAG01.AddEdge("A", "B");
DAG01.AddEdge("A", "X");
DAG01.AddEdge("B", "C");
DAG01.AddEdge("C", "D");
DAG01.AddEdge("D", "E");
DAG01.AddEdge("E", "X");
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG01.ToReadable() + "\r\n");
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort01 = TopologicalSorter.Sort<string>(DAG01);
var output01 = string.Empty;
foreach(var node in topologicalSort01)
output01 = String.Format("{0}({1}) ", output01, node);
// PRINT THE TOPOLOGICAL SORT
Console.WriteLine("Was the previous graph cyclic? " + output01);
Console.WriteLine("\r\n*********************************************\r\n");
/**************************************************************************/
var V02 = new int[] { 7, 5, 3, 11, 8, 2, 9, 10 };
var DAG02 = new DirectedSparseGraph<int>();
// Insert new values of V
DAG02.AddVertices(V02);
// Insert new value for edges
DAG02.AddEdge(7, 11);
DAG02.AddEdge(7, 8);
DAG02.AddEdge(5, 11);
DAG02.AddEdge(3, 8);
DAG02.AddEdge(3, 10);
DAG02.AddEdge(11, 2);
DAG02.AddEdge(11, 9);
DAG02.AddEdge(11, 10);
DAG02.AddEdge(8, 9);
// PRINT THE GRAPH
Console.WriteLine("[*] DAG (Directed Asyclic Graph):");
Console.WriteLine(DAG02.ToReadable() + "\r\n");
// CALCULATE THE TOPOLOGICAL SORT
var topologicalSort02 = TopologicalSorter.Sort<int>(DAG02);
var output02 = string.Empty;
foreach (var node in topologicalSort02)
output02 = String.Format("{0}({1}) ", output02, node);
// PRINT THE TOPOLOGICAL SORT
Console.WriteLine("Was the previous graph cyclic? " + output02);
Console.WriteLine("\r\n*********************************************\r\n");
Console.ReadLine();
}
