switch to List<List<Integer>> for tree

Author: lennart

src/main/java/com/thealgorithms/tree/CentroidDecomposition.java

@@ -29,19 +29,18 @@
  */
 
 public class CentroidDecomposition {
-    private final List<Integer>[] tree;
-    private final List<Integer>[] centroidTree;
+    private final List<List<Integer>> tree;
+    private final List<List<Integer>> centroidTree;
     private int[] subtreeSizes;
     private boolean[] visited;
     private boolean[] centroidMarked;
     private int[] centroidParent;
     private int startingNode;
     private final int n;
 
-    @SuppressWarnings("unchecked")
     public CentroidDecomposition(int n, int startingNode) {
-        this.tree = (List<Integer>[]) new ArrayList<?>[n];
-        this.centroidTree = (List<Integer>[]) new ArrayList<?>[n];
+        this.tree = new ArrayList<>();
+        this.centroidTree = new ArrayList<>();
         this.n = n;
         centroidMarked = new boolean[n];
         centroidParent = new int[n];
@@ -53,8 +52,8 @@ public CentroidDecomposition(int n, int startingNode) {
         this.startingNode = startingNode;
         for (int i = 0; i < n; i++) {
             centroidParent[i] = -1;
-            tree[i] = new ArrayList<>();
-            centroidTree[i] = new ArrayList<>();
+            tree.add(new ArrayList<>());
+            centroidTree.add(new ArrayList<>());
         }
     }
 
@@ -69,7 +68,7 @@ public void build() {
 
     public void reset() {
         for (int i = 0; i < n; i++) {
-            centroidTree[i].clear();
+            centroidTree.get(i).clear();
             centroidParent[i] = -1;
             subtreeSizes[i] = 0;
             centroidMarked[i] = false;
@@ -86,17 +85,17 @@ public int[] getSubtreeSizes() {
     }
 
     public void addEdgeTree(int u, int v) {
-        tree[u].add(v);
-        tree[v].add(u);
+        tree.get(u).add(v);
+        tree.get(v).add(u);
     }
 
     private void addEdgeCTree(int u, int v) {
-        centroidTree[u].add(v);
-        centroidTree[v].add(u);
+        centroidTree.get(u).add(v);
+        centroidTree.get(v).add(u);
         centroidParent[v] = u;
     }
 
-    public List<Integer>[] getCentroidTree() {
+    public List<List<Integer>> getCentroidTree() {
         return centroidTree;
     }
 
@@ -105,7 +104,7 @@ public int getParent(int v) {
     }
 
     public List<Integer> getCentroidChildren(int v) {
-        return centroidTree[v].stream().filter(child -> centroidParent[child] == v && centroidParent[v] != child).collect(Collectors.toList());
+        return centroidTree.get(v).stream().filter(child -> centroidParent[child] == v && centroidParent[v] != child).collect(Collectors.toList());
     }
 
     public int getRoot() {
@@ -120,7 +119,7 @@ public int getRoot() {
     public void findSubtreeSizes(int src) {
         visited[src] = true;
         subtreeSizes[src] = 1;
-        for (int node : tree[src]) {
+        for (int node : tree.get(src)) {
             if (!visited[node] && !centroidMarked[node]) {
                 visited[node] = true;
                 findSubtreeSizes(node);
@@ -135,7 +134,7 @@ public void findCentroid(int src, int previousCentroid) {
         int treeSize = subtreeSizes[src];
         int heavyChild = -1;
 
-        for (int node : tree[src]) {
+        for (int node : tree.get(src)) {
             if (centroidMarked[node]) {
                 continue;
             }
@@ -156,7 +155,7 @@ public void findCentroid(int src, int previousCentroid) {
             addEdgeCTree(previousCentroid, src);
         }
 
-        for (int node : tree[src]) {
+        for (int node : tree.get(src)) {
             if (!centroidMarked[node]) {
                 findCentroid(node, src);
             }

src/test/java/com/thealgorithms/tree/CentroidDecompositionTest.java

@@ -136,10 +136,10 @@ void buildSetsExpectedParentsForKeyNodes() {
     @Test
     void centroidAdjacencyFor8And11MatchesIgnoringOrder() {
         cd.build();
-        List<Integer>[] cg = cd.getCentroidTree();
+        List<List<Integer>> cg = cd.getCentroidTree();
 
-        List<Integer> actual8 = new ArrayList<>(cg[8]);
-        List<Integer> actual11 = new ArrayList<>(cg[11]);
+        List<Integer> actual8 = new ArrayList<>(cg.get(8));
+        List<Integer> actual11 = new ArrayList<>(cg.get(8));
 
         List<Integer> expected8 = Arrays.asList(0, 3, 9, 10);
         List<Integer> expected11 = Arrays.asList(0, 2, 12, 14);
@@ -158,9 +158,9 @@ void resetClearsCentroidData() {
         cd.build();
         cd.reset();
 
-        List<Integer>[] cg = cd.getCentroidTree();
-        for (int i = 0; i < cg.length; i++) {
-            assertTrue(cg[i].isEmpty(), "centroid adjacency must be empty after reset");
+        List<List<Integer>> cg = cd.getCentroidTree();
+        for (int i = 0; i < cg.size(); i++) {
+            assertTrue(cg.get(i).isEmpty(), "centroid adjacency must be empty after reset");
             assertEquals(-1, cd.getParent(i), "parent must be -1 after reset");
         }
 
@@ -207,13 +207,13 @@ private static void assertValidCentroidTree(CentroidDecomposition cd, int n) {
         int roots = 0;
         int edges = 0;
 
-        List<Integer>[] cg = cd.getCentroidTree();
+        List<List<Integer>> cg = cd.getCentroidTree();
 
         for (int v = 0; v < n; v++) {
             if (cd.getParent(v) == -1) {
                 roots++;
             }
-            edges += cg[v].size();
+            edges += cg.get(v).size();
         }
 
         // undirected edges counted twice
@@ -244,25 +244,24 @@ private static void copyEdges(CentroidDecomposition from, CentroidDecomposition
     @Test
     void testBuildCentroidTree() {
         cd.build();
-        List<Integer>[] centroidTree = cd.getCentroidTree();
-        List<Integer> correctEight = new ArrayList<Integer>();
-        List<Integer> correctEleven = new ArrayList<Integer>();
+        List<List<Integer>> centroidTree = cd.getCentroidTree();
+
+        List<Integer> correctEight = new ArrayList<>();
         correctEight.add(0);
         correctEight.add(3);
         correctEight.add(9);
         correctEight.add(10);
 
+        List<Integer> correctEleven = new ArrayList<>();
         correctEleven.add(0);
         correctEleven.add(2);
         correctEleven.add(12);
         correctEleven.add(14);
 
-        for (int j = 0; j < centroidTree[8].size(); j++) {
-            assertEquals(correctEight.get(j), centroidTree[8].get(j));
-        }
+        List<Integer> actualEight = centroidTree.get(8);
+        List<Integer> actualEleven = centroidTree.get(8);
 
-        for (int j = 0; j < centroidTree[11].size(); j++) {
-            assertEquals(correctEleven.get(j), centroidTree[11].get(j));
-        }
+        assertEquals(correctEight, actualEight);
+        assertEquals(correctEleven, actualEleven);
     }
 }