Merge branch 'feature/topologicalsort' into develop

Author: bguiz

README.md

@@ -35,8 +35,8 @@ General purpose data structures and algorithms.
 - [ ] Graph
   - [ ] Directed Matrix Graph
   - [ ] Undirected Matrix Graph
-  - [ ] Directed Adjacency Graph
-  - [ ] Undirected Adjacency Graph
+  - [x] Directed Adjacency Graph
+  - [x] Undirected Adjacency Graph
   - [ ] Directed Edged Graph
   - [ ] Undirected Edged Graph
   - [ ] Flow Capacity Graph
@@ -69,7 +69,7 @@ General purpose data structures and algorithms.
   - [ ] Cyclic Components
   - [ ] Euler Tour
     - Visit each edge once
-  - [ ] Topological Sort
+  - [x] Topological Sort
 - [ ] Graph Minimum Spanning Tree
   - [ ] Lazy Prim's Minimum Spanning Tree
   - [ ] Eager Prim's Minimum Spanning Tree

src/bguiz/struct/graph/BreadthFirstSearchGraph.hx

@@ -3,6 +3,7 @@ package bguiz.struct.graph;
 import bguiz.struct.dict.ArrayDictionary;
 using bguiz.struct.dict.ArrayQueue;
 
+@:expose("Struct.BreadthFirstSearchGraph")
 class BreadthFirstSearchGraph {
   public static function breadthFirstSearch<T> (
     graph: AdjacencyGraph<T>,

src/bguiz/struct/graph/ConnectedSearchGraphResult.hx

@@ -2,6 +2,6 @@ package bguiz.struct.graph;
 
 typedef ConnectedSearchGraphResult<T> = {
   > SearchGraphResult<T>,
-  var connected:Array<Int>;
+  var connected:Array<Null<Int>>;
   var groupCount:Int;
 }

src/bguiz/struct/graph/DepthFirstSearchGraph.hx

@@ -3,10 +3,12 @@ package bguiz.struct.graph;
 import bguiz.struct.dict.ArrayDictionary;
 using bguiz.struct.dict.ArrayStack;
 
+@:expose("Struct.DepthFirstSearchGraph")
 class DepthFirstSearchGraph {
   public static function depthFirstSearch<T> (
     graph: AdjacencyGraph<T>,
-    startVertex:Int): SearchGraphResult<T> {
+    startVertex: Int
+  ): SearchGraphResult<T> {
     var result = {
       startVertex: startVertex,
       edgeTo: [for (i in 0...graph.vertices.length) null],
@@ -17,8 +19,9 @@ class DepthFirstSearchGraph {
   }
 
   public static function  depthFirstSearchPart<T> (
-    graph:AdjacencyGraph<T>,
-    startVertex:Int, result:SearchGraphResult<T>
+    graph: AdjacencyGraph<T>,
+    startVertex: Int,
+    result: SearchGraphResult<T>
   ): Void {
     // recursion in a typical DFS implementation is so simple here
     // that a stack-based implementation is very simple

src/bguiz/struct/graph/SearchGraphResult.hx

@@ -2,6 +2,6 @@ package bguiz.struct.graph;
 
 typedef SearchGraphResult<T> = {
   var startVertex:Int;
-  var edgeTo:Array<Int>;
+  var edgeTo:Array<Null<Int>>;
   var marked:Array<Bool>;
 }

src/bguiz/struct/graph/TopologicalSortGraph.hx

@@ -0,0 +1,45 @@
+package bguiz.struct.graph;
+
+import bguiz.struct.dict.ArrayDictionary;
+using bguiz.struct.dict.ArrayStack;
+
+//NOTE *must* be a directed acyclic graph (DAG) i.e. no cycles
+@:expose("Struct.TopologicalSortGraph")
+class TopologicalSortGraph {
+
+  // Find an order of all the vetrices such that the all of
+  // the directed edges point in the same direction
+  // Perform a depth first search, and then returnthe vertices in reverse post order
+  // Every vertex must be searched, hence no start vertex needs to be specified
+  public static function topologicalSort<T> (
+    graph: AdjacencyGraph<T>
+  ): TopologicalSortGraphResult<T> {
+    var result = {
+      reversePostOrderVertices: [],
+      marked: [for (i in 0...graph.vertices.length) false]
+    };
+    for (i in 0...graph.vertices.length) {
+      if (!result.marked[i]) {
+        topologicalSortPart(graph, i, result);
+      }
+    }
+    return result;
+  }
+
+  public static function topologicalSortPart<T> (
+    graph: AdjacencyGraph<T>,
+    fromVertex: Int,
+    result: TopologicalSortGraphResult<T>
+  ) : Void {
+    //TODO find a way to do this iteratively (rather than recursively)
+    // however tracking reverse post order of the depth first search
+    // proves to be tricky to implement
+    result.marked[fromVertex] = true;
+    for (toVertex in graph.adjacents[fromVertex]) {
+      if (!result.marked[toVertex]) {
+        topologicalSortPart(graph, toVertex, result);
+      }
+    }
+    result.reversePostOrderVertices.push(fromVertex);
+  }
+}

src/bguiz/struct/graph/TopologicalSortGraphResult.hx

@@ -0,0 +1,6 @@
+package bguiz.struct.graph;
+
+typedef TopologicalSortGraphResult<T> = {
+  var marked:Array<Bool>;
+  var reversePostOrderVertices:Array<Int>;
+}

test/bguiz/struct/test/graph/TopologicalSortGraphTest.hx

@@ -0,0 +1,80 @@
+package bguiz.struct.test.graph;
+
+import massive.munit.util.Timer;
+import massive.munit.Assert;
+import massive.munit.async.AsyncFactory;
+
+import bguiz.struct.graph.AdjacencyGraph;
+using bguiz.struct.graph.DirectedAdjacencyGraph;
+
+import bguiz.struct.graph.TopologicalSortGraphResult;
+using bguiz.struct.graph.TopologicalSortGraph;
+
+class TopologicalSortGraphTest {
+
+  public static function assertArrayEqual <T>(a: Array<T>, b: Array<T>): Void {
+    Assert.areEqual(a.toString(), b.toString());
+    Assert.areEqual(a.length, b.length);
+    var i:Int = 0;
+    while (i < a.length) {
+      Assert.areEqual(a[i], b[i]);
+      ++i;
+    }
+  }
+
+  @Test
+  public function testConnectedComponentsSearch1() {
+    var graph:AdjacencyGraph<Int> =
+      DirectedAdjacencyGraph.make([for (i in 0...4) i]);
+
+    graph.addEdge(0, 1);
+    graph.addEdge(1, 2);
+    graph.addEdge(2, 3);
+
+    var result:TopologicalSortGraphResult<Int> =
+      graph.topologicalSort();
+
+    assertArrayEqual([3,2,1,0], result.reversePostOrderVertices);
+  }
+
+  @Test
+  public function testConnectedComponentsSearch2() {
+    var graph:AdjacencyGraph<Int> =
+      DirectedAdjacencyGraph.make([for (i in 0...4) i]);
+
+    graph.addEdge(0, 1);
+    graph.addEdge(0, 3);
+    graph.addEdge(1, 3);
+    graph.addEdge(2, 3);
+    graph.addEdge(2, 0);
+
+    var result:TopologicalSortGraphResult<Int> =
+      graph.topologicalSort();
+
+    assertArrayEqual([3,1,0,2], result.reversePostOrderVertices);
+  }
+
+  @Test
+  public function testConnectedComponentsSearch3() {
+    var graph:AdjacencyGraph<Int> =
+      DirectedAdjacencyGraph.make([for (i in 0...7) i]);
+
+    graph.addEdge(0, 1);
+    graph.addEdge(0, 2);
+
+    graph.addEdge(1, 3);
+
+    graph.addEdge(2, 3);
+    graph.addEdge(2, 4);
+
+    graph.addEdge(3, 5);
+    graph.addEdge(3, 6);
+
+    graph.addEdge(4, 5);
+
+    var result:TopologicalSortGraphResult<Int> =
+      graph.topologicalSort();
+
+    assertArrayEqual([5,6,3,1,4,2,0], result.reversePostOrderVertices);
+  }
+}