#102 二叉树的分层遍历

Author: Isaaclot

main/src/tree/LC_102_BinaryTreeLevelOrder.java

@@ -0,0 +1,57 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * @author alis
+ * @date 2019/11/1 12:17 AM
+ * @description
+ */
+public class LC_102_BinaryTreeLevelOrder {
+
+    List<List<Integer>> result = new ArrayList<>();
+
+
+    /**
+     * BFS
+     * 时间复杂度：O(n)
+     */
+    public List<List<Integer>> levelOrderBFS(TreeNode root) {
+        helper(root, 0);
+        return result;
+    }
+
+    private void helper(TreeNode root, int level) {
+        // init level 0
+        if (level == result.size())
+            result.add(new ArrayList<>());
+        // process current
+        result.get(level).add(root.val);
+        // drill down
+        if (null != root.left)
+            helper(root.left, level + 1); // 同一个level层的数据都会同样处理，并只处理一遍
+        if (null != root.right)
+            helper(root.right, level + 1);
+    }
+
+    public List<List<Integer>> levelOrderLoop(TreeNode root) {
+        if (null == root) return result;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Integer> current = new ArrayList<>();
+            while (size-- > 0) {
+                TreeNode node = queue.poll();
+                current.add(node.val);
+                if (node.left != null) queue.add(node.left);
+                if (node.right != null) queue.add(node.right);
+            }
+            result.add(current);
+        }
+        return result;
+    }
+}

main/test/tree/LC_102_BinaryTreeLevelOrderTest.java

@@ -0,0 +1,55 @@
+package tree;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * @author alis
+ * @date 2019/11/1 12:09 AM
+ * @description
+ */
+public class LC_102_BinaryTreeLevelOrderTest {
+
+    private LC_102_BinaryTreeLevelOrder binaryTreeLevelOrder = new LC_102_BinaryTreeLevelOrder();
+
+    @Test
+    public void testLevelOrderRecur() {
+        TreeNode root3 = new TreeNode(3);
+        TreeNode right20 = new TreeNode(20);
+        right20.left = new TreeNode(15);
+        right20.right = new TreeNode(7);
+        root3.left = new TreeNode(9);
+        root3.right = right20;
+        List<List<Integer>> result = binaryTreeLevelOrder.levelOrderBFS(root3);
+        List<List<Integer>> except = new ArrayList<>();
+        except.add(Collections.singletonList(3));
+        except.add(Arrays.asList(9, 20));
+        except.add(Arrays.asList(15, 7));
+        assertThat(result, is(except));
+
+    }
+
+    @Test
+    public void testLevelOrderLoop() {
+        TreeNode root3 = new TreeNode(3);
+        TreeNode right20 = new TreeNode(20);
+        right20.left = new TreeNode(15);
+        right20.right = new TreeNode(7);
+        root3.left = new TreeNode(9);
+        root3.right = right20;
+        List<List<Integer>> result = binaryTreeLevelOrder.levelOrderLoop(root3);
+        List<List<Integer>> except = new ArrayList<>();
+        except.add(Collections.singletonList(3));
+        except.add(Arrays.asList(9, 20));
+        except.add(Arrays.asList(15, 7));
+        assertThat(result, is(except));
+
+    }
+}