Tree Isomorphism tests and slides

Author: williamfiset

com/williamfiset/algorithms/graphtheory/treealgorithms/TreeIsomorphism.java

@@ -13,6 +13,7 @@
 import java.util.*;
 
 public class TreeIsomorphism {
+
   public static class TreeNode {
     private int id;
     private TreeNode parent;
@@ -103,6 +104,10 @@ private static List<Integer> findTreeCenters(List<List<Integer>> tree) {
 
   // Determines if two unrooted trees are isomorphic
   public static boolean treesAreIsomorphic(List<List<Integer>> tree1, List<List<Integer>> tree2) {
+    if (tree1.isEmpty() || tree2.isEmpty()) {
+      throw new IllegalArgumentException("Empty tree input");
+    }
+
     List<Integer> centers1 = findTreeCenters(tree1);
     List<Integer> centers2 = findTreeCenters(tree2);
 
@@ -121,7 +126,7 @@ private static boolean areIsomorphic(TreeNode root1, TreeNode root2) {
 
   // Constructs the canonical form representation of a tree as a string.
   private static String encode(TreeNode node) {
-    if (node == null || node.isLeaf()) {
+    if (node == null) {
       return "()";
     }
     List<String> labels = new LinkedList<>();
@@ -137,13 +142,13 @@ private static String encode(TreeNode node) {
   }
 
   // Create a graph as a adjacency list
-  private static List<List<Integer>> createGraph(int n) {
+  public static List<List<Integer>> createGraph(int n) {
     List<List<Integer>> graph = new ArrayList<>(n);
     for (int i = 0; i < n; i++) graph.add(new LinkedList<>());
     return graph;
   }
 
-  private static void addUndirectedEdge(List<List<Integer>> graph, int from, int to) {
+  public static void addUndirectedEdge(List<List<Integer>> graph, int from, int to) {
     graph.get(from).add(to);
     graph.get(to).add(from);
   }
@@ -170,5 +175,4 @@ public static void main(String[] args) {
       System.out.println("Oops something is not right.");
     }
   }
-
 }

javatests/com/williamfiset/algorithms/graphtheory/treealgorithms/TreeIsomorphismTest.java

@@ -0,0 +1,129 @@
+// To run this test in isolation from root folder:
+//
+// $ gradle test --tests javatests.com.williamfiset.algorithms.graphtheory.treealgorithms.TreeIsomorphismTest
+
+package javatests.com.williamfiset.algorithms.graphtheory.treealgorithms;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static com.williamfiset.algorithms.graphtheory.treealgorithms.TreeIsomorphism.addUndirectedEdge;
+import static com.williamfiset.algorithms.graphtheory.treealgorithms.TreeIsomorphism.createGraph;
+import static com.williamfiset.algorithms.graphtheory.treealgorithms.TreeIsomorphism.treesAreIsomorphic;
+
+import java.util.*;
+import org.junit.*;
+
+public class TreeIsomorphismTest {
+
+  @Test(expected = IllegalArgumentException.class)
+  public void emptyTreeThrowsException() {
+    treesAreIsomorphic(createGraph(0), createGraph(1));
+  }
+
+  @Test
+  public void singletonTreesAreIsomorphic() {
+    assertThat(treesAreIsomorphic(createGraph(1), createGraph(1))).isEqualTo(true);
+  }
+
+  @Test
+  public void testTwoNodeTree() {
+    List<List<Integer>> tree1 = createGraph(2);
+    List<List<Integer>> tree2 = createGraph(2);
+    addUndirectedEdge(tree1, 0, 1);
+    addUndirectedEdge(tree2, 1, 0);
+    assertThat(treesAreIsomorphic(tree1, tree2)).isEqualTo(true);
+  }
+
+  @Test
+  public void testSmall() {
+    List<List<Integer>> tree1 = createGraph(5);
+    List<List<Integer>> tree2 = createGraph(5);
+
+    addUndirectedEdge(tree1, 2, 0);
+    addUndirectedEdge(tree1, 2, 1);
+    addUndirectedEdge(tree1, 2, 3);
+    addUndirectedEdge(tree1, 3, 4);
+
+    addUndirectedEdge(tree2, 1, 3);
+    addUndirectedEdge(tree2, 1, 0);
+    addUndirectedEdge(tree2, 1, 2);
+    addUndirectedEdge(tree2, 2, 4);
+
+    assertThat(treesAreIsomorphic(tree1, tree2)).isEqualTo(true);
+  }
+
+  @Test
+  public void testSimilarChains() {
+    // Trees 1 and 3 are equal
+    int n = 10;
+    List<List<Integer>> tree1 = createGraph(n);
+    List<List<Integer>> tree2 = createGraph(n);
+    List<List<Integer>> tree3 = createGraph(n);
+
+    addUndirectedEdge(tree1, 0, 1);
+    addUndirectedEdge(tree1, 1, 3);
+    addUndirectedEdge(tree1, 3, 5);
+    addUndirectedEdge(tree1, 5, 7);
+    addUndirectedEdge(tree1, 7, 8);
+    addUndirectedEdge(tree1, 8, 9);
+    addUndirectedEdge(tree1, 2, 1);
+    addUndirectedEdge(tree1, 4, 3);
+    addUndirectedEdge(tree1, 6, 5);
+
+    addUndirectedEdge(tree2, 0, 1);
+    addUndirectedEdge(tree2, 1, 3);
+    addUndirectedEdge(tree2, 3, 5);
+    addUndirectedEdge(tree2, 5, 6);
+    addUndirectedEdge(tree2, 6, 8);
+    addUndirectedEdge(tree2, 8, 9);
+    addUndirectedEdge(tree2, 6, 7);
+    addUndirectedEdge(tree2, 4, 3);
+    addUndirectedEdge(tree2, 2, 1);
+
+    addUndirectedEdge(tree3, 0, 1);
+    addUndirectedEdge(tree3, 1, 8);
+    addUndirectedEdge(tree3, 1, 6);
+    addUndirectedEdge(tree3, 6, 4);
+    addUndirectedEdge(tree3, 6, 5);
+    addUndirectedEdge(tree3, 5, 3);
+    addUndirectedEdge(tree3, 5, 7);
+    addUndirectedEdge(tree3, 7, 2);
+    addUndirectedEdge(tree3, 2, 9);
+
+    assertThat(treesAreIsomorphic(tree1, tree2)).isEqualTo(false);
+    assertThat(treesAreIsomorphic(tree1, tree3)).isEqualTo(true);
+    assertThat(treesAreIsomorphic(tree2, tree3)).isEqualTo(false);
+  }
+
+  @Test
+  public void simpleTest() {
+    List<List<Integer>> tree1 = createGraph(5);
+    List<List<Integer>> tree2 = createGraph(5);
+
+    addUndirectedEdge(tree1, 2, 0);
+    addUndirectedEdge(tree1, 3, 4);
+    addUndirectedEdge(tree1, 2, 1);
+    addUndirectedEdge(tree1, 2, 3);
+
+    addUndirectedEdge(tree2, 1, 0);
+    addUndirectedEdge(tree2, 2, 4);
+    addUndirectedEdge(tree2, 1, 3);
+    addUndirectedEdge(tree2, 1, 2);
+
+    assertThat(treesAreIsomorphic(tree1, tree2)).isEqualTo(true);
+  }
+
+  @Test
+  public void differentNumberOfNodes() {
+    List<List<Integer>> tree1 = createGraph(2);
+    List<List<Integer>> tree2 = createGraph(3);
+
+    addUndirectedEdge(tree1, 0, 1);
+
+    addUndirectedEdge(tree2, 0, 1);
+    addUndirectedEdge(tree2, 1, 2);
+
+    assertThat(treesAreIsomorphic(tree1, tree2)).isEqualTo(false);
+  }
+
+}