Add 102. Binary Tree Level Order Traversal.md

102. Binary Tree Level Order Traversal.md

@@ -0,0 +1,177 @@
+# step 1
+階層別BFSをすれば良い
+
+ノードの数をnとして、
+- time complexity: O(n)
+- space complexity: O(n)
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+
+        nodes = [root]
+        result = []
+        while nodes:
+            values_in_this_level = []
+            nodes_in_next_level = []
+            for node in nodes:
+                values_in_this_level.append(node.val)
+                if node.left is not None:
+                    nodes_in_next_level.append(node.left)
+                if node.right is not None:
+                    nodes_in_next_level.append(node.right)
+            result.append(values_in_this_level)
+            nodes = nodes_in_next_level
+        return result
+```
+
+Noneもとりあえずつっこんであとから処理するタイプの階層別BFS。
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        nodes = [root]
+        result = []
+        while True:
+            nodes = list(filter(None, nodes))
+            if not nodes:
+                break
+            values_in_this_level = []
+            nodes_in_next_level = []
+            for node in nodes:
+                values_in_this_level.append(node.val)
+                nodes_in_next_level.append(node.left)
+                nodes_in_next_level.append(node.right)
+            result.append(values_in_this_level)
+            nodes = nodes_in_next_level
+        return result
+```
+
+# step 2
+- https://github.com/Mike0121/LeetCode/pull/7/files#r1587410964
+    - >resultはもう少し命名頑張っても良いかも。level_ordered_valuesとかどうでしょうか？
+- https://github.com/hayashi-ay/leetcode/pull/32/files
+    - DFS preorder recursive traversal、階層別でないdequeを使ったBFS
+
+感想:BFS以外の書き方が思いつかなかったが、levelさえトラックしていればDFSでやろうが動作する。
+
+iterative, preorder DFS traversal
+- time complexity: O(n)
+- space complexity: O(n)
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        level_ordered_values = []
+        nodes_and_levels = [(root, 0)]
+        while nodes_and_levels:
+            node, level = nodes_and_levels.pop()
+            if node is None:
+                continue
+            while not len(level_ordered_values) > level:
+                level_ordered_values.append([])
+            level_ordered_values[level].append(node.val)
+            nodes_and_levels.append((node.right, level + 1))
+            nodes_and_levels.append((node.left, level + 1))
+        return level_ordered_values
+```
+
+recursive, preorder DFS traversal,
+2パターン書いてみたが、あまり名前がしっくりこない。
+
+- time complexity: O(n)
+- space complexity: O(n)
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def traverse_nodes_in_preorder(
+            node: Optional[TreeNode],
+            level: int
+        ) -> None:
+            if node is None:
+                return
+
+            nonlocal level_ordered_values
+            while not len(level_ordered_values) > level:
+                level_ordered_values.append([])
+            level_ordered_values[level].append(node.val)
+            traverse_nodes_in_preorder(node.left, level + 1)
+            traverse_nodes_in_preorder(node.right, level + 1)
+
+        level_ordered_values = []
+        traverse_nodes_in_preorder(root, 0)
+        return level_ordered_values
+```
+
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def collect_values_in_preorder(
+            level_ordered_values: List[List[int]],
+            node: Optional[TreeNode],
+            level: int
+        ) -> List[List[int]]:
+            if node is None:
+                return level_ordered_values
+            while not len(level_ordered_values) > level:
+                level_ordered_values.append([])
+            level_ordered_values[level].append(node.val)
+            collect_values_in_preorder(
+                level_ordered_values,
+                node.left,
+                level + 1
+            )
+            collect_values_in_preorder(
+                level_ordered_values,
+                node.right,
+                level + 1
+            )
+            return level_ordered_values
+        return collect_values_in_preorder([], root, 0)
+```
+
+階層化していないBFS
+```python
+from collections import deque
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        level_ordered_values = []
+        nodes_and_levels = deque([(root, 0)])
+        while nodes_and_levels:
+            node, level = nodes_and_levels.popleft()
+            if node is None:
+                continue
+            while not len(level_ordered_values) > level:
+                level_ordered_values.append([])
+            level_ordered_values[level].append(node.val)
+            nodes_and_levels.append((node.left, level + 1))
+            nodes_and_levels.append((node.right, level + 1))
+        return level_ordered_values
+```
+
+# step 3
+
+結局最初の書き方に戻った
+
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+
+        level_ordered_values = []
+        nodes_in_level = [root]
+        while nodes_in_level:
+            nodes_in_next_level = []
+            values_in_level = []
+            for node in nodes_in_level:
+                values_in_level.append(node.val)
+                if node.left is not None:
+                    nodes_in_next_level.append(node.left)
+                if node.right is not None:
+                    nodes_in_next_level.append(node.right)
+            nodes_in_level = nodes_in_next_level
+            level_ordered_values.append(values_in_level)
+        return level_ordered_values
+```