Binary Tree Level Order Traversal - Recursive

Author: dksifoua

src/main/java/io/dksifoua/leetcode/binarytreelevelordertraversal/Solution.java

@@ -34,4 +34,23 @@ public List<List<Integer>> levelOrder(TreeNode root) {
 
         return result;
     }
+
+    public List<List<Integer>> levelOrderRecursive(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if (root == null) return result;
+
+        dfs(root, 0, result);
+        return result;
+    }
+
+    private void dfs(TreeNode node, int level, List<List<Integer>> result) {
+        if (level <= result.size() - 1) {
+            result.get(level).add(node.getValue());
+        } else {
+            result.add(new ArrayList<>() {{ add(node.getValue()); }});
+        }
+
+        if (node.getLeft() != null) dfs(node.getLeft(), level + 1, result);
+        if (node.getRight() != null) dfs(node.getRight(), level + 1, result);
+    }
 }

src/test/java/io/dksifoua/leetcode/binarytreelevelordertraversal/SolutionTest.java

@@ -27,6 +27,22 @@ void test1() {
         }
     }
 
+    @Test
+    void test1Recursive() {
+        TreeNode root = TreeNode.build(new Integer[] { 3, 9, 20, null, null, 15, 7 });
+        List<List<Integer>> expected = new ArrayList<>() {{
+            add(List.of(3));
+            add(List.of(9, 20));
+            add(List.of(15, 7));
+        }};
+        List<List<Integer>> actual = solution.levelOrderRecursive(root);
+
+        Assertions.assertEquals(expected.size(), actual.size());
+        for (int i = 0; i < expected.size(); i++) {
+            Assertions.assertArrayEquals(expected.get(i).toArray(), actual.get(i).toArray());
+        }
+    }
+
     @Test
     void test2() {
         TreeNode root = TreeNode.build(new Integer[] { 1});
@@ -41,11 +57,33 @@ void test2() {
         }
     }
 
+    @Test
+    void test2Recursive() {
+        TreeNode root = TreeNode.build(new Integer[] { 1});
+        List<List<Integer>> expected = new ArrayList<>() {{
+            add(List.of(1));
+        }};
+        List<List<Integer>> actual = solution.levelOrderRecursive(root);
+
+        Assertions.assertEquals(expected.size(), actual.size());
+        for (int i = 0; i < expected.size(); i++) {
+            Assertions.assertArrayEquals(expected.get(i).toArray(), actual.get(i).toArray());
+        }
+    }
+
     @Test
     void test3() {
         TreeNode root = TreeNode.build(new Integer[] {  });
         List<List<Integer>> actual = solution.levelOrder(root);
 
         Assertions.assertEquals(0, actual.size());
     }
+
+    @Test
+    void test3Recursive() {
+        TreeNode root = TreeNode.build(new Integer[] {  });
+        List<List<Integer>> actual = solution.levelOrderRecursive(root);
+
+        Assertions.assertEquals(0, actual.size());
+    }
 }