changes implementation to match MIT OCW 6006

Author: selfeki

src/graphs/TopologicalSort.re

@@ -3,13 +3,9 @@ type node = {
     neighbours: list(string),
 };
 
-type mark =
-  | Temp
-  | Perm;
-
 type directedGraph = list(node);
 
-exception Not_found(string);
+exception Invalid_node_id(string);
 
 exception Graph_not_DAG;
 
@@ -21,9 +17,9 @@ let parseAdjList = adj_list => {
 
     List.iter(insert, adj_list);
     let validateNeighbours = node => {
-        List.iter(neighbour => {
-            if (!Hashtbl.mem(adj_tbl, neighbour)) {
-                raise(Not_found(neighbour));
+        List.iter(neighbour_id => {
+            if (!Hashtbl.mem(adj_tbl, neighbour_id)) {
+                raise(Invalid_node_id(neighbour_id));
             }
         }, node.neighbours);
     };
@@ -32,44 +28,46 @@ let parseAdjList = adj_list => {
     adj_tbl;
 };
 
-let rec visit = (~node_id, ~adj_tbl, ~mark_tbl, ~list) => {
-    if (Hashtbl.mem(mark_tbl, node_id)) {
-        switch (Hashtbl.find(mark_tbl, node_id)) {
-            | Temp => raise(Graph_not_DAG);
-            | Perm => list;
+let rec visit = (~node_id, ~adj_tbl, ~visited, ~ordering, ~ancestors) => {
+    if (Hashtbl.mem(visited, node_id)) {
+        let pred = id => id == node_id;
+        switch (List.find(pred, ancestors)) {
+        | exception Not_found => ordering;
+        | _ => raise(Graph_not_DAG);
         };
     }
     else {
+        let ancestors = List.append(ancestors, [node_id]);
         let neighbours = Hashtbl.find(adj_tbl, node_id);
-        let visitNeighbour = (sorting, neighbour_id) => {
+        let visitNeighbour = (ordering, neighbour_id) => {
             visit(
             ~node_id=neighbour_id,
             ~adj_tbl=adj_tbl,
-            ~mark_tbl=mark_tbl,
-            ~list=sorting);
+            ~visited=visited,
+            ~ordering=ordering,
+            ~ancestors=ancestors);
         };
 
-        Hashtbl.add(mark_tbl, node_id, Temp);
-        let list = List.fold_left(visitNeighbour, list, neighbours);
-        Hashtbl.add(mark_tbl, node_id, Perm);
-
+        Hashtbl.add(visited, node_id, node_id);
+        let list = List.fold_left(visitNeighbour, ordering, neighbours);
         List.append(list, [node_id]);
     };
 };
 
 let sort = adj_list => {
     let num_nodes = List.length(adj_list);
-    let mark_tbl = Hashtbl.create(num_nodes);
     let adj_tbl = parseAdjList(adj_list);
+    let visited = Hashtbl.create(num_nodes);
 
-    let traverse = (list, node) => {
+    let traverse = (ordering, node) => {
         visit(
         ~node_id=node.id, 
         ~adj_tbl=adj_tbl,
-        ~mark_tbl=mark_tbl,
-        ~list=list);
+        ~visited=visited,
+        ~ordering=ordering,
+        ~ancestors=[]);
     };
 
-    let list = List.fold_left(traverse, [], adj_list);
-    List.rev(list);
+    let top_sorting = List.fold_left(traverse, [], adj_list);
+    List.rev(top_sorting);
 };