Added tests for Kahn's algorithm

Author: William Fiset

src/main/java/com/williamfiset/algorithms/graphtheory/Kahns.java

@@ -1,5 +1,8 @@
-// ./gradlew run -Palgorithm=graphtheory.Kahns
-
+/**
+ * Implementation of Kahn's algorithm
+ *
+ * <p>./gradlew run -Palgorithm=graphtheory.Kahns
+ */
 package com.williamfiset.algorithms.graphtheory;
 
 import java.util.*;

src/main/java/com/williamfiset/algorithms/utils/graphutils/GraphGenerator.java

@@ -0,0 +1,64 @@
+package com.williamfiset.algorithms.utils.graphutils;
+
+import java.util.*;
+
+public class GraphGenerator {
+
+  public static class DagGenerator {
+    double edgeProbability;
+    int minLevels, maxLevels, minNodesPerLevel, maxNodesPerLevel;
+
+    // Generates a DAg gives several parameters. Make sure the edge probability
+    // is high enough to make a mostly connected graph.
+    public DagGenerator(
+        int minLevels,
+        int maxLevels,
+        int minNodesPerLevel,
+        int maxNodesPerLevel,
+        double edgeProbability) {
+      this.minLevels = minLevels;
+      this.maxLevels = maxLevels;
+      this.minNodesPerLevel = minNodesPerLevel;
+      this.maxNodesPerLevel = maxNodesPerLevel;
+      this.edgeProbability = edgeProbability;
+    }
+
+    /**
+     * @param min - The minimum.
+     * @param max - The maximum.
+     * @return A random double between these numbers (inclusive the minimum and maximum).
+     */
+    private static int rand(int min, int max) {
+      return min + (int) (Math.random() * ((max - min) + 1));
+    }
+
+    public List<List<Integer>> createDag() {
+      int levels = rand(minLevels, maxLevels);
+      int[] nodesPerLevel = new int[levels];
+
+      int n = 0;
+      for (int l = 0; l < levels; l++) {
+        nodesPerLevel[l] = rand(minNodesPerLevel, maxNodesPerLevel);
+        n += nodesPerLevel[l];
+      }
+      List<List<Integer>> g = Utils.createEmptyAdjacencyList(n);
+      int levelIndex = 0;
+      for (int l = 0; l < levels - 1; l++) { // For each level
+        for (int i = 0; i < nodesPerLevel[l]; i++) { // for each node on each level
+          for (int j = 0; j < nodesPerLevel[l + 1]; j++) { // for each possible edge link
+            if (Math.random() <= edgeProbability) {
+              Utils.addDirectedEdge(g, levelIndex + i, levelIndex + nodesPerLevel[l] + j);
+            }
+          }
+        }
+        levelIndex += nodesPerLevel[l];
+      }
+      return g;
+    }
+  }
+
+  public static void main(String[] args) {
+    DagGenerator gen = new DagGenerator(10, 10, 5, 5, 0.9);
+    gen.createDag();
+  }
+}

src/test/java/com/williamfiset/algorithms/graphtheory/KahnsTest.java

@@ -0,0 +1,71 @@
+package com.williamfiset.algorithms.graphtheory;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.williamfiset.algorithms.utils.graphutils.GraphGenerator;
+import com.williamfiset.algorithms.utils.graphutils.Utils;
+import java.util.*;
+import org.junit.*;
+
+public class KahnsTest {
+
+  private static boolean find(List<List<Integer>> g, boolean[] vis, int at, int target) {
+    List<Integer> edges = g.get(at);
+    if (edges.size() == 0 || vis[at]) {
+      return false;
+    }
+    if (at == target) {
+      return true;
+    }
+    vis[at] = true;
+    for (int next : edges) {
+      if (find(g, vis, next, target)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Verifies that the topological ordering is not violated, O(n^2)
+  private static boolean isTopsortOrdering(List<List<Integer>> g, int[] order) {
+    int n = g.size();
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j < n; j++) {
+        // jAppearsBeforeNodeI
+        if (find(g, new boolean[n], order[j], order[i])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  @Test
+  public void verifyIsTopsortOrdering() {
+    List<List<Integer>> g = Utils.createEmptyAdjacencyList(3);
+    Utils.addDirectedEdge(g, 0, 1);
+    Utils.addDirectedEdge(g, 1, 2);
+    int[] order = {2, 1, 0};
+    assertThat(isTopsortOrdering(g, order)).isEqualTo(false);
+  }
+
+  @Test
+  public void randomTest() {
+    GraphGenerator.DagGenerator dagGen = new GraphGenerator.DagGenerator(10, 10, 5, 5, 0.86);
+    List<List<Integer>> g = dagGen.createDag();
+    Kahns solver = new Kahns();
+    int[] order = solver.kahns(g);
+    assertThat(isTopsortOrdering(g, order)).isEqualTo(true);
+  }
+
+  @Test
+  public void randomTests() {
+    for (double p = 0.7; p <= 1.0; p += 0.02) {
+      GraphGenerator.DagGenerator dagGen = new GraphGenerator.DagGenerator(2, 20, 4, 15, p);
+      List<List<Integer>> g = dagGen.createDag();
+      Kahns solver = new Kahns();
+      int[] order = solver.kahns(g);
+      assertThat(isTopsortOrdering(g, order)).isEqualTo(true);
+    }
+  }
+}