Add 'Binary Tree Level Order Traversal'

Author: nickolashkraus

README.md

@@ -8,6 +8,8 @@ A collection of LeetCode solutions
 
 [Binary Search](./src/binary_search.py)
 
+[Binary Tree Level Order Traversal](./src/binary_tree_level_order_traversal.py)
+
 [Climbing Stairs](./src/climbing_stairs.py)
 
 [Coin Change](./src/coin_change.py)

src/binary_tree_level_order_traversal.py

@@ -0,0 +1,59 @@
+"""
+102. Binary Tree Level Order Traversal
+
+https://leetcode.com/problems/binary-tree-level-order-traversal
+
+NOTES
+  * Use depth-first or breadth-first search. The strategy for keeping track of
+    the current level is slightly different for each approach. For depth-first
+    search, pass the level with the recursive call. For breadth-first search,
+    dequeue the entire level all at once, add the nodes to the result, then
+    enqueue all child nodes.
+"""
+
+from collections import deque
+
+from src.classes import TreeNode
+
+
+class Solution:
+    def levelOrder(self, root: TreeNode | None) -> list[list[int]]:
+        if not root:
+            return []
+
+        levels: list[list[int]] = []
+        queue: deque[TreeNode] = deque([root])
+        level = 0
+
+        while queue:
+            levels.append([])
+            # Loop invariant: The length of the queue is the width of the
+            # level.
+            for _ in range(len(queue)):
+                curr = queue.popleft()
+                levels[level].append(curr.val)
+                if curr.left:
+                    queue.append(curr.left)
+                if curr.right:
+                    queue.append(curr.right)
+            level += 1
+
+        return levels
+
+
+class SolutionDFS:
+    def levelOrder(self, root: TreeNode | None) -> list[list[int]]:
+        if not root:
+            return []
+        levels: list[list[int]] = []
+        self._levelOrder(root, 0, levels)
+        return levels
+
+    def _levelOrder(self, root: TreeNode | None, level: int, levels: list[list[int]]) -> None:
+        if not root:
+            return
+        if len(levels) < level + 1:
+            levels.append([])
+        levels[level].append(root.val)
+        self._levelOrder(root.left, level + 1, levels)
+        self._levelOrder(root.right, level + 1, levels)

tests/test_binary_tree_level_order_traversal.py

@@ -0,0 +1,44 @@
+"""
+102. Binary Tree Level Order Traversal
+
+https://leetcode.com/problems/binary-tree-level-order-traversal
+"""
+
+from unittest import TestCase
+
+from src.binary_tree_level_order_traversal import Solution, SolutionDFS
+from tests.utils import create_binary_tree_from_list
+
+
+class TestSolution(TestCase):
+    def test_1(self):
+        exp = [[3], [9, 20], [15, 7]]
+        root = create_binary_tree_from_list([3, 9, 20, None, None, 15, 7])
+        assert Solution().levelOrder(root) == exp
+
+    def test_2(self):
+        exp = [[1]]
+        root = create_binary_tree_from_list([1])
+        assert Solution().levelOrder(root) == exp
+
+    def test_3(self):
+        exp = []
+        root = create_binary_tree_from_list([])
+        assert Solution().levelOrder(root) == exp
+
+
+class TestSolutionDFS(TestCase):
+    def test_1(self):
+        exp = [[3], [9, 20], [15, 7]]
+        root = create_binary_tree_from_list([3, 9, 20, None, None, 15, 7])
+        assert SolutionDFS().levelOrder(root) == exp
+
+    def test_2(self):
+        exp = [[1]]
+        root = create_binary_tree_from_list([1])
+        assert SolutionDFS().levelOrder(root) == exp
+
+    def test_3(self):
+        exp = []
+        root = create_binary_tree_from_list([])
+        assert SolutionDFS().levelOrder(root) == exp