From 50762f82b1d6112ef92257bf4206c65ac9b8062e Mon Sep 17 00:00:00 2001 From: Taito Ohsumi Date: Tue, 4 Mar 2025 15:01:50 +1100 Subject: [PATCH] Add 102. Binary Tree Level Order Traversal.md --- 102. Binary Tree Level Order Traversal.md | 177 ++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 102. Binary Tree Level Order Traversal.md diff --git a/102. Binary Tree Level Order Traversal.md b/102. Binary Tree Level Order Traversal.md new file mode 100644 index 0000000..435e14d --- /dev/null +++ b/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 +``` \ No newline at end of file