public void RemoveEdge_ShouldRemoveEdge_AndSetProperties()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.True(graph.Edges.Count() == 2);
Assert.True(graph.EdgesCount == 2);
var expectedOutgoingFromA = new List <string>()
{
"z", "s"
};
Assert.True(graph.OutgoingEdges("a").Select(e => e.Destination).SequenceEqual(expectedOutgoingFromA));
Assert.True(graph.IncomingEdges("z").Any());
var result = graph.RemoveEdge("a", "z");
Assert.True(result);
Assert.True(graph.Edges.Count() == 1);
Assert.True(graph.EdgesCount == 1);
expectedOutgoingFromA = new List <string>()
{
"s"
};
Assert.True(graph.OutgoingEdges("a").Select(e => e.Destination).SequenceEqual(expectedOutgoingFromA));
Assert.False(graph.IncomingEdges("z").Any());
}
public void RemoveEdge_ShoudlReturnFalse_WhenEdgeNotExists()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
Assert.False(graph.RemoveEdge("a", "z"));
}
public void GetEdge_ShouldReturnNull_WhenEdgeNotFound()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s", "b" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.Null(graph.GetEdge("a", "b"));
}
public void GetEdge_ShouldThrowException_WhenSearchVertexNotFound()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.Throws <ArgumentOutOfRangeException>(() => graph.GetEdge("a", "A"));
}
public void UpdateEdgeWeight_ShouldReturnFalse_WhenEdgeNotFound()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.False(graph.UpdateEdgeWeight("z", "s", 10));
}
public void IncommingEdges_ShouldThrowException_WhenVertexNotExists()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.Throws <ArgumentOutOfRangeException>(() => graph.IncomingEdges("A").Any());
}
public void UpdateEdgeWeight_ShouldUpdateWeight_OfCSpecificEdge()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.Equal(1, graph.GetEdgeWeight("a", "s"));
graph.UpdateEdgeWeight("a", "s", 10);
Assert.Equal(10, graph.GetEdgeWeight("a", "s"));
}
public void AddEdge_ShouldCreateEdge_WithProvidedWeight()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var vertices = new string[] { "a", "z", "s" };
graph.AddVertices(vertices);
Assert.True(graph.VerticesCount == 3);
Assert.True(graph.Vertices.SequenceEqual(vertices));
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
Assert.True(graph.Edges.Count() == 2);
Assert.True(graph.EdgesCount == 2);
var edgeToS = graph.GetEdge("a", "s");
Assert.Equal("s", edgeToS.Destination);
Assert.Equal("a", edgeToS.Source);
Assert.Equal(1, edgeToS.Weight);
var edgeToZ = graph.GetEdge("a", "z");
Assert.Equal("z", edgeToZ.Destination);
Assert.Equal("a", edgeToZ.Source);
Assert.Equal(2, edgeToZ.Weight);
var expectedOutgoingFromA = new List <string>()
{
"z", "s"
};
Assert.True(graph.OutgoingEdges("a").Select(e => e.Destination).SequenceEqual(expectedOutgoingFromA));
Assert.Single(graph.OutgoingEdges("s"));
Assert.Single(graph.OutgoingEdges("z"));
var expectedIncomming = new List <string>()
{
"a"
};
Assert.True(graph.IncomingEdges("s").Select(e => e.Source).SequenceEqual(expectedIncomming));
Assert.True(graph.IncomingEdges("z").Select(e => e.Source).SequenceEqual(expectedIncomming));
Assert.Equal(2, graph.IncomingEdges("a").Count());
}
public void IsWeighted_Should_AlwaysReturnTrue()
{
var graph = new UndirectedWeightedDenseGraph <int>();
Assert.True(graph.IsWeighted);
}
public static void DoTest()
{
var graph = new UndirectedWeightedDenseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "f", 1);
graph.AddEdge("d", "c", 2);
graph.AddEdge("d", "s", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("c", "v", 2);
var allEdges = graph.Edges.ToList();
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 11, "Wrong edges count.");
Assert.True(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Assert.True(graph.OutgoingEdges("a").ToList().Count == 3, "Wrong outgoing edges from 'a'.");
Assert.True(graph.OutgoingEdges("s").ToList().Count == 3, "Wrong outgoing edges from 's'.");
Assert.True(graph.OutgoingEdges("x").ToList().Count == 4, "Wrong outgoing edges from 'x'.");
Assert.True(graph.OutgoingEdges("d").ToList().Count == 4, "Wrong outgoing edges from 'd'.");
Assert.True(graph.OutgoingEdges("c").ToList().Count == 4, "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 == 2, "Wrong outgoing edges from 'f'.");
Assert.True(graph.OutgoingEdges("z").ToList().Count == 1, "Wrong outgoing edges from 'z'.");
Assert.True(graph.IncomingEdges("a").ToList().Count == 3, "Wrong incoming edges from 'a'.");
Assert.True(graph.IncomingEdges("s").ToList().Count == 3, "Wrong incoming edges from 's'.");
Assert.True(graph.IncomingEdges("x").ToList().Count == 4, "Wrong incoming edges from 'x'.");
Assert.True(graph.IncomingEdges("d").ToList().Count == 4, "Wrong incoming edges from 'd'.");
Assert.True(graph.IncomingEdges("c").ToList().Count == 4, "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 == 2, "Wrong incoming edges from 'f'.");
Assert.True(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
var f_to_c = graph.HasEdge("f", "c");
var f_to_c_weight = graph.GetEdgeWeight("f", "c");
Assert.True(f_to_c == true, "Edge f->c doesn't exist.");
Assert.True(f_to_c_weight == 1, "Edge f->c must have a weight of 1.");
var d_to_s = graph.HasEdge("d", "s");
var d_to_s_weight = graph.GetEdgeWeight("d", "s");
Assert.True(d_to_s == true, "Edge d->s doesn't exist.");
Assert.True(d_to_s_weight == 3, "Edge d->s must have a weight of 3.");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 8, "Wrong edges count.");
graph.RemoveVertex("x");
Assert.True(graph.VerticesCount == 7, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 4, "Wrong edges count.");
graph.AddVertex("x");
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "c", 2);
graph.AddEdge("c", "v", 2);
graph.AddEdge("a", "z", 2);
// BFS from A
// Walk the graph using BFS from A:
var bfsWalk = graph.BreadthFirstWalk("a");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
// output: (s) (a) (x) (z) (d) (c) (f) (v)
Assert.True(bfsWalk.SequenceEqual(new[] { "s", "a", "x", "z", "d", "c", "f", "v" }));
// DFS from A
// Walk the graph using DFS from A:
var dfsWalk = graph.DepthFirstWalk("a");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
Assert.True(bfsWalk.SequenceEqual(new[] { "s", "a", "x", "z", "d", "c", "f", "v" }));
// BFS from F
// Walk the graph using BFS from F:
bfsWalk = graph.BreadthFirstWalk("f");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
Assert.True(bfsWalk.SequenceEqual(new[] { "s", "a", "x", "z", "d", "c", "f", "v" }));
// DFS from F
// Walk the graph using DFS from F:
dfsWalk = graph.DepthFirstWalk("f");
// output: (s) (a) (x) (z) (d) (c) (f) (v)
Assert.True(bfsWalk.SequenceEqual(new[] { "s", "a", "x", "z", "d", "c", "f", "v" }));
/********************************************************************/
graph.Clear();
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b", 1);
graph.AddEdge("a", "d", 2);
graph.AddEdge("b", "e", 3);
graph.AddEdge("d", "b", 1);
graph.AddEdge("d", "e", 2);
graph.AddEdge("e", "c", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("f", "f", 1);
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)
Assert.True(bfsWalk.SequenceEqual(new[] { "a", "b", "e", "d", "c", "f" }));
Console.ReadLine();
}
public static void DoTest()
{
var graph = new UndirectedWeightedDenseGraph<string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "f", 1);
graph.AddEdge("d", "c", 2);
graph.AddEdge("d", "s", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("c", "v", 2);
var allEdges = graph.Edges.ToList();
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 11, "Wrong edges count.");
Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 3, "Wrong outgoing edges from 'a'.");
Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 3, "Wrong outgoing edges from 's'.");
Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 4, "Wrong outgoing edges from 'x'.");
Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 4, "Wrong outgoing edges from 'd'.");
Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 4, "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 == 2, "Wrong outgoing edges from 'f'.");
Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 1, "Wrong outgoing edges from 'z'.");
Debug.Assert(graph.IncomingEdges("a").ToList().Count == 3, "Wrong incoming edges from 'a'.");
Debug.Assert(graph.IncomingEdges("s").ToList().Count == 3, "Wrong incoming edges from 's'.");
Debug.Assert(graph.IncomingEdges("x").ToList().Count == 4, "Wrong incoming edges from 'x'.");
Debug.Assert(graph.IncomingEdges("d").ToList().Count == 4, "Wrong incoming edges from 'd'.");
Debug.Assert(graph.IncomingEdges("c").ToList().Count == 4, "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 == 2, "Wrong incoming edges from 'f'.");
Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
Console.WriteLine("[*] Undirected Weighted Dense Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
var f_to_c = graph.HasEdge("f", "c");
var f_to_c_weight = graph.GetEdgeWeight("f", "c");
Debug.Assert(f_to_c == true, "Edge f->c doesn't exist.");
Debug.Assert(f_to_c_weight == 1, "Edge f->c must have a weight of 1.");
Console.WriteLine("Is there an edge from f to c? " + f_to_c + ". If yes it's weight is: " + f_to_c_weight + ".");
var d_to_s = graph.HasEdge("d", "s");
var d_to_s_weight = graph.GetEdgeWeight("d", "s");
Debug.Assert(d_to_s == true, "Edge d->s doesn't exist.");
Debug.Assert(d_to_s_weight == 3, "Edge d->s must have a weight of 3.");
Console.WriteLine("Is there an edge from d to d? " + d_to_s + ". If yes it's weight is: " + d_to_s_weight + ".");
Console.WriteLine();
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "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 == 4, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "c", 2);
graph.AddEdge("c", "v", 2);
graph.AddEdge("a", "z", 2);
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();
/********************************************************************/
Console.WriteLine("***************************************************\r\n");
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", 1);
graph.AddEdge("a", "d", 2);
graph.AddEdge("b", "e", 3);
graph.AddEdge("d", "b", 1);
graph.AddEdge("d", "e", 2);
graph.AddEdge("e", "c", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("f", "f", 1);
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Undirected Weighted Dense 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 graph = new UndirectedWeightedDenseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s", 1);
graph.AddEdge("a", "z", 2);
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "f", 1);
graph.AddEdge("d", "c", 2);
graph.AddEdge("d", "s", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("c", "v", 2);
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 11, "Wrong edges count.");
Console.WriteLine("[*] Undirected Weighted Dense Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
var f_to_c = graph.HasEdge("f", "c");
var f_to_c_weight = graph.GetEdgeWeight("f", "c");
Debug.Assert(f_to_c == true, "Edge f->c doesn't exist.");
Debug.Assert(f_to_c_weight == 1, "Edge f->c must have a weight of 1.");
Console.WriteLine("Is there an edge from f to c? " + f_to_c + ". If yes it's weight is: " + f_to_c_weight + ".");
var d_to_s = graph.HasEdge("d", "s");
var d_to_s_weight = graph.GetEdgeWeight("d", "s");
Debug.Assert(d_to_s == true, "Edge d->s doesn't exist.");
Debug.Assert(d_to_s_weight == 3, "Edge d->s must have a weight of 3.");
Console.WriteLine("Is there an edge from d to d? " + d_to_s + ". If yes it's weight is: " + d_to_s_weight + ".");
Console.WriteLine();
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "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 == 4, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x", 3);
graph.AddEdge("x", "d", 1);
graph.AddEdge("x", "c", 2);
graph.AddEdge("x", "a", 3);
graph.AddEdge("d", "c", 2);
graph.AddEdge("c", "v", 2);
graph.AddEdge("a", "z", 2);
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();
/********************************************************************/
Console.WriteLine("***************************************************\r\n");
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", 1);
graph.AddEdge("a", "d", 2);
graph.AddEdge("b", "e", 3);
graph.AddEdge("d", "b", 1);
graph.AddEdge("d", "e", 2);
graph.AddEdge("e", "c", 3);
graph.AddEdge("c", "f", 1);
graph.AddEdge("f", "f", 1);
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Undirected Weighted Dense 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();
}
