Feature/104 maximum depth of binary tree

src/binary_tree/dfs/maximum_depth_of_binary_tree/solution.py

@@ -0,0 +1,9 @@
+from typing import Optional
+from structures import TreeNode
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

src/stack/decode_string/solution.py

@@ -6,10 +6,10 @@ def decodeString(self, s: str) -> str:
         for char in s:
             if char.isdigit():
                 number.append(char)
-            elif char == '[':
+            elif char == "[":
                 stack.append("".join(number))
                 number = []
-            elif char == ']':
+            elif char == "]":
                 alphas = []
                 while stack[-1].isalpha():
                     alphas.append(stack.pop())

structures/__init__.py

@@ -0,0 +1,3 @@
+from .tree import TreeNode
+
+__all__ = ["TreeNode"]

structures/tree.py

@@ -0,0 +1,5 @@
+class TreeNode:
+    def __init__(self, val: int = 0, left: int | None = None, right: int | None = None):
+        self.val = val
+        self.left = left
+        self.right = right

test_utils/__init__.py

@@ -0,0 +1,3 @@
+from .tree_builder import TreeBuilder
+
+__all__ = ["TreeBuilder"]

test_utils/tree_builder.py

@@ -0,0 +1,29 @@
+from collections import deque
+from typing import Optional
+from structures import TreeNode
+
+
+class TreeBuilder:
+    @staticmethod
+    def from_list(values: list[Optional[int]]) -> Optional[TreeNode]:
+        if not values or values[0] is None:
+            return None
+
+        root = TreeNode(values[0])
+        queue = deque([root])
+        i = 1
+
+        while queue and i < len(values):
+            node = queue.popleft()
+
+            if i < len(values) and values[i] is not None:
+                node.left = TreeNode(values[i])
+                queue.append(node.left)
+            i += 1
+
+            if i < len(values) and values[i] is not None:
+                node.right = TreeNode(values[i])
+                queue.append(node.right)
+            i += 1
+
+        return root

tests/test_maximum_depth_of_binary_tree.py

@@ -0,0 +1,16 @@
+import pytest
+from src.binary_tree.dfs.maximum_depth_of_binary_tree.solution import Solution
+from test_utils import TreeBuilder
+
+
+@pytest.mark.parametrize(
+    "root, expected",
+    [
+        ([3, 9, 20, None, None, 15, 7], 3),
+        ([1, None, 2], 2),
+    ],
+)
+def test_max_depth(root, expected):
+    root = TreeBuilder.from_list(root)
+    solution = Solution()
+    assert solution.maxDepth(root) == expected