public void RetreiveAllNodeNeighbors()
{
///Test that all node neighbors can be retreived
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
Node testV3 = new Node("Test3");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
graph.AddEdge(testV2, testV3, 8);
Edge testEdge = new Edge(testV1, testV2, 4);
Edge testEdge2 = new Edge(testV2, testV3, 8);
List <Node> expected = new List <Node>();
expected.Add(testEdge.V1);
expected.Add(testEdge2.V1);
List <Edge> graphEdges = graph.GetNeighbors(testV2);
List <Node> actual = new List <Node>();
foreach (Edge e in graphEdges)
{
actual.Add(e.V1);
}
Assert.Equal(expected, actual);
}
private static void PerformGraphOps()
{
var graph = new Graphs();
graph.AddNode("a");
graph.AddNode("b");
graph.AddNode("c");
graph.AddEdge("a", "b");
graph.AddEdge("a", "c");
graph.Print();
var graph2 = new Graphs();
graph2.AddNode("a");
graph2.AddNode("b");
graph2.AddNode("c");
graph2.AddNode("d");
graph2.AddEdge("a", "b");
graph2.AddEdge("a", "c");
graph2.AddEdge("b", "d");
graph2.AddEdge("d", "c");
Console.WriteLine("Recursive Depth First Traversal");
graph2.RecursiveDepthFirstTraversal("a");
Console.WriteLine("Iterative Depth First Traversal");
graph2.IterativeDepthFirstTraversal("a");
Console.WriteLine("Breadth First Traversal");
graph2.BreadthFirstTraversal("a");
var graph3 = new Graphs();
graph3.AddNode("x");
graph3.AddNode("a");
graph3.AddNode("b");
graph3.AddNode("p");
graph3.AddEdge("x", "a");
graph3.AddEdge("x", "b");
graph3.AddEdge("a", "p");
graph3.AddEdge("b", "p");
Console.WriteLine("Topolocally Sorted List");
graph3.TopologicalSort().ForEach(x =>
{
Console.WriteLine(x);
});
var graph4 = new Graphs();
graph4.AddNode("a");
graph4.AddNode("b");
graph4.AddNode("c");
graph4.AddNode("d");
graph4.AddEdge("a", "b");
graph4.AddEdge("b", "c");
graph4.AddEdge("c", "a");
graph4.AddEdge("a", "d");
Console.WriteLine("Graph contains Cycle" + graph4.IsCyclePresent());
}
public static void Main(string[] args)
{
Node Pandora = new Node("Pandora");
Node Arendelle = new Node("Arendelle");
Node Metroville = new Node("Metroville");
Node Monstropolis = new Node("Monstropolis");
Node Narnia = new Node("Narnia");
Node Naboo = new Node("Naboo");
Graphs flights = new Graphs(Metroville);
flights.AddEdge(Metroville, new Tuple <Node, int>(Narnia, 37));
flights.AddEdge(Metroville, new Tuple <Node, int>(Naboo, 26));
flights.AddEdge(Metroville, new Tuple <Node, int>(Monstropolis, 105));
flights.AddEdge(Metroville, new Tuple <Node, int>(Arendelle, 99));
flights.AddEdge(Metroville, new Tuple <Node, int>(Pandora, 82));
flights.AddEdge(Pandora, new Tuple <Node, int>(Arendelle, 150));
flights.AddEdge(Arendelle, new Tuple <Node, int>(Monstropolis, 42));
flights.AddEdge(Monstropolis, new Tuple <Node, int>(Naboo, 73));
flights.AddEdge(Naboo, new Tuple <Node, int>(Narnia, 250));
Node[] trip1 = new Node[] { Metroville, Arendelle };
Node[] trip2 = new Node[] { Narnia, Metroville, Arendelle };
Node[] trip3 = new Node[] { Naboo, Pandora };
Console.WriteLine(GetEdges(trip1, flights));
Console.WriteLine(GetEdges(trip2, flights));
Console.WriteLine(GetEdges(trip3, flights));
}
public void AddEdgeToGraph()
{
///Test that edge can be successfully added
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
Edge testEdge = new Edge(testV1, testV2, 4);
List <Node> expected = new List <Node>();
expected.Add(testEdge.V1);
List <Edge> graphEdges = graph.GetNeighbors(testV2);
List <Node> actual = new List <Node>();
foreach (Edge e in graphEdges)
{
actual.Add(e.V1);
}
Assert.Equal(expected, actual);
}
public void CanReturnSizeOfGraphWithZeroWeight()
{
Node nodeOne = new Node("nodeOne");
Node nodeTwo = new Node("nodeTwo");
Node nodeThree = new Node("nodeThree");
Node nodeFour = new Node("nodeFour");
Node nodeFive = new Node("nodeFive");
Graphs myGraph = new Graphs(nodeOne);
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeTwo, 0));
myGraph.AddEdge(nodeTwo, new Tuple <Node, int>(nodeThree, 0));
myGraph.AddEdge(nodeThree, new Tuple <Node, int>(nodeFour, 0));
myGraph.AddEdge(nodeFour, new Tuple <Node, int>(nodeFive, 0));
myGraph.AddEdge(nodeFive, new Tuple <Node, int>(nodeOne, 0));
Assert.Equal(5, myGraph.Size());
}
public void CanAddEdgeWithZeroWeight()
{
Node nodeOne = new Node("nodeOne");
Node nodeTwo = new Node("nodeTwo");
Node nodeThree = new Node("nodeThree");
Node nodeFour = new Node("nodeFour");
Node nodeFive = new Node("nodeFive");
Graphs myGraph = new Graphs(nodeOne);
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeTwo, 0));
myGraph.AddEdge(nodeTwo, new Tuple <Node, int>(nodeThree, 0));
myGraph.AddEdge(nodeThree, new Tuple <Node, int>(nodeFour, 0));
myGraph.AddEdge(nodeFour, new Tuple <Node, int>(nodeFive, 0));
myGraph.AddEdge(nodeFive, new Tuple <Node, int>(nodeOne, 0));
Assert.NotEmpty(myGraph.GetNodes());
}
public void RetreiveGraphSize()
{
///Test graph size returns accordingly
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
Node testV3 = new Node("Test3");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
graph.AddEdge(testV2, testV3, 8);
int expected = 2;
Assert.Equal(expected, graph.GetSize());
}
public void CanReturnListOfNeighborNodes()
{
Node nodeOne = new Node("nodeOne");
Node nodeTwo = new Node("nodeTwo");
Node nodeThree = new Node("nodeThree");
Node nodeFour = new Node("nodeFour");
Node nodeFive = new Node("nodeFive");
Graphs myGraph = new Graphs(nodeOne);
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeTwo, 5));
myGraph.AddEdge(nodeTwo, new Tuple <Node, int>(nodeThree, 10));
myGraph.AddEdge(nodeThree, new Tuple <Node, int>(nodeFour, 15));
myGraph.AddEdge(nodeFour, new Tuple <Node, int>(nodeFive, 20));
myGraph.AddEdge(nodeFive, new Tuple <Node, int>(nodeOne, 25));
Assert.NotEmpty(myGraph.GetNeighbors(nodeOne));
}
public void ReturnMultiVisitedNodes()
{
///test that method will return ordered list of visited nodes
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
Node testV3 = new Node("Test3");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddNode(testV3);
graph.AddEdge(testV1, testV2, 4);
graph.AddEdge(testV2, testV3, 8);
List <Node> expected = new List <Node>();
expected.Add(testV3);
expected.Add(testV2);
Assert.Equal(expected, graph.BreadFirst(testV3));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
DepthFirst(graph);
}
public void RetreiveVertices()
{
///test that method will return all vertices/Vertex
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
List <Node> expected = new List <Node>();
expected.Add(testV1);
expected.Add(testV2);
Assert.Equal(expected, graph.GetNodes());
}
public void CanFindDirectFlightMultipleLayovers()
{
Node Pandora = new Node("Pandora");
Node Arendelle = new Node("Arendelle");
Node Metroville = new Node("Metroville");
Node Monstropolis = new Node("Monstropolis");
Node Narnia = new Node("Narnia");
Node Naboo = new Node("Naboo");
Graphs flights = new Graphs(Metroville);
flights.AddEdge(Metroville, new Tuple <Node, int>(Narnia, 37));
flights.AddEdge(Metroville, new Tuple <Node, int>(Naboo, 26));
flights.AddEdge(Metroville, new Tuple <Node, int>(Monstropolis, 105));
flights.AddEdge(Metroville, new Tuple <Node, int>(Arendelle, 99));
flights.AddEdge(Metroville, new Tuple <Node, int>(Pandora, 82));
flights.AddEdge(Pandora, new Tuple <Node, int>(Arendelle, 150));
flights.AddEdge(Arendelle, new Tuple <Node, int>(Monstropolis, 42));
flights.AddEdge(Monstropolis, new Tuple <Node, int>(Naboo, 73));
flights.AddEdge(Naboo, new Tuple <Node, int>(Narnia, 250));
Node[] trip2 = new Node[] { Narnia, Metroville, Arendelle };
Assert.Equal("True $136", GetEdges(trip2, flights));
}
public void CanFindNoDirectFlight()
{
Node Pandora = new Node("Pandora");
Node Arendelle = new Node("Arendelle");
Node Metroville = new Node("Metroville");
Node Monstropolis = new Node("Monstropolis");
Node Narnia = new Node("Narnia");
Node Naboo = new Node("Naboo");
Graphs flights = new Graphs(Metroville);
flights.AddEdge(Metroville, new Tuple <Node, int>(Narnia, 37));
flights.AddEdge(Metroville, new Tuple <Node, int>(Naboo, 26));
flights.AddEdge(Metroville, new Tuple <Node, int>(Monstropolis, 105));
flights.AddEdge(Metroville, new Tuple <Node, int>(Arendelle, 99));
flights.AddEdge(Metroville, new Tuple <Node, int>(Pandora, 82));
flights.AddEdge(Pandora, new Tuple <Node, int>(Arendelle, 150));
flights.AddEdge(Arendelle, new Tuple <Node, int>(Monstropolis, 42));
flights.AddEdge(Monstropolis, new Tuple <Node, int>(Naboo, 73));
flights.AddEdge(Naboo, new Tuple <Node, int>(Narnia, 250));
Node[] trip3 = new Node[] { Naboo, Pandora };
Assert.Equal("False $0", GetEdges(trip3, flights));
}
public static Graphs OpenGraph(string filename)
{
FileStream stream = new FileStream(filename, FileMode.Open);
BinaryReader binaryReader = new BinaryReader(stream);
Graphs graph = new Graphs();
int n = binaryReader.ReadInt32();
for (int i = 0; i < n; i++)
{
graph.AddNode(binaryReader.ReadInt32(), binaryReader.ReadInt32());
}
n = binaryReader.ReadInt32();
for (int i = 0; i < n; i++)
{
graph.AddEdge(graph.Nodes[binaryReader.ReadInt32()], graph.Nodes[binaryReader.ReadInt32()]);
}
binaryReader.Close();
stream.Close();
return(graph);
}
public void RetreiveWeightNeighbors()
{
///Test that all weight can be retrieved from neighbors
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
Node testV2 = new Node("Test2");
graph.AddNode(testV1);
graph.AddNode(testV2);
graph.AddEdge(testV1, testV2, 4);
Edge testEdge = new Edge(testV1, testV2, 4);
List <Edge> graphEdges = graph.GetNeighbors(testV2);
int weight = 0;
foreach (Edge e in graphEdges)
{
weight = e.Weight;
}
Assert.Equal(testEdge.Weight, weight);
}
public void RetreiveSingleNodeandEdge()
{
///Test that a single vertex and edge can be found
Graphs graph = new Graphs();
Node testV1 = new Node("Test1");
graph.AddNode(testV1);
graph.AddEdge(testV1, testV1, 4);
Edge testEdge = new Edge(testV1, testV1, 4);
List <Node> expected = new List <Node>();
expected.Add(testEdge.V1);
List <Edge> graphEdges = graph.GetNeighbors(testV1);
List <Node> actual = new List <Node>();
foreach (Edge e in graphEdges)
{
actual.Add(e.V1);
}
Assert.Equal(expected, actual);
}
public void CanGetMultipleNeighborsFromGraph()
{
Node nodeOne = new Node("nodeOne");
Node nodeTwo = new Node("nodeTwo");
Node nodeThree = new Node("nodeThree");
Node nodeFour = new Node("nodeFour");
Node nodeFive = new Node("nodeFive");
Graphs myGraph = new Graphs(nodeOne);
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeTwo, 5));
myGraph.AddEdge(nodeTwo, new Tuple <Node, int>(nodeThree, 10));
myGraph.AddEdge(nodeThree, new Tuple <Node, int>(nodeFour, 15));
myGraph.AddEdge(nodeFour, new Tuple <Node, int>(nodeFive, 20));
myGraph.AddEdge(nodeFive, new Tuple <Node, int>(nodeOne, 25));
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeThree, 742));
Assert.Equal(3, myGraph.GetNeighbors(nodeOne).Count);
}
public void NodesCanHaveMultipleEdges()
{
Node nodeOne = new Node("nodeOne");
Node nodeTwo = new Node("nodeTwo");
Node nodeThree = new Node("nodeThree");
Node nodeFour = new Node("nodeFour");
Node nodeFive = new Node("nodeFive");
Graphs myGraph = new Graphs(nodeOne);
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeTwo, 5));
myGraph.AddEdge(nodeTwo, new Tuple <Node, int>(nodeThree, 10));
myGraph.AddEdge(nodeThree, new Tuple <Node, int>(nodeFour, 15));
myGraph.AddEdge(nodeFour, new Tuple <Node, int>(nodeFive, 20));
myGraph.AddEdge(nodeFive, new Tuple <Node, int>(nodeOne, 25));
myGraph.AddEdge(nodeOne, new Tuple <Node, int>(nodeThree, 742));
Assert.NotEmpty(myGraph.GetNodes());
}
