Added tests 104-139

Author: ThanhNIT

src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution0104.py

@@ -4,6 +4,13 @@
 # #Top_Interview_150_Binary_Tree_General #Big_O_Time_O(N)_Space_O(H)
 # #2025_07_25_Time_0_ms_(100.00%)_Space_19.23_MB_(7.43%)
 
+from typing import Optional
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):

src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution0104_test.py

@@ -0,0 +1,33 @@
+import unittest
+from Solution0104 import Solution, TreeNode
+
+def build_tree(values):
+    if not values:
+        return None
+    root = TreeNode(values[0])
+    queue = [root]
+    i = 1
+    while queue and i < len(values):
+        node = queue.pop(0)
+        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
+
+class SolutionTest(unittest.TestCase):
+    def test_maxDepth(self):
+        root = build_tree([3, 9, 20, None, None, 15, 7])
+        self.assertEqual(Solution().maxDepth(root), 3)
+
+    def test_maxDepth2(self):
+        root = build_tree([1, None, 2])
+        self.assertEqual(Solution().maxDepth(root), 2)
+
+    def test_maxDepth3(self):
+        root = build_tree([])
+        self.assertEqual(Solution().maxDepth(root), 0)

src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution0105.py

@@ -2,6 +2,13 @@
 # #Divide_and_Conquer #Data_Structure_II_Day_15_Tree #Top_Interview_150_Binary_Tree_General
 # #Big_O_Time_O(N)_Space_O(N) #2025_07_25_Time_4_ms_(73.84%)_Space_19.14_MB_(84.59%)
 
+from typing import Optional, List
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):

src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution0105_test.py

@@ -0,0 +1,38 @@
+import unittest
+from Solution0105 import Solution, TreeNode
+
+def tree_to_list(root):
+    if not root:
+        return []
+    result = []
+    queue = [root]
+    while queue:
+        node = queue.pop(0)
+        if node:
+            result.append(node.val)
+            queue.append(node.left)
+            queue.append(node.right)
+        else:
+            result.append(None)
+    # Remove trailing None values
+    while result and result[-1] is None:
+        result.pop()
+    return result
+
+class SolutionTest(unittest.TestCase):
+    def test_buildTree(self):
+        preorder = [3, 9, 20, 15, 7]
+        inorder = [9, 3, 15, 20, 7]
+        result = Solution().buildTree(preorder, inorder)
+        # Check that the tree structure is correct by comparing values
+        self.assertEqual(result.val, 3)
+        self.assertEqual(result.left.val, 9)
+        self.assertEqual(result.right.val, 20)
+
+    def test_buildTree2(self):
+        preorder = [-1]
+        inorder = [-1]
+        result = Solution().buildTree(preorder, inorder)
+        self.assertEqual(result.val, -1)
+        self.assertIsNone(result.left)
+        self.assertIsNone(result.right)

src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution0114.py

@@ -2,6 +2,13 @@
 # #Udemy_Linked_List #Top_Interview_150_Binary_Tree_General #Big_O_Time_O(N)_Space_O(N)
 # #2025_07_25_Time_0_ms_(100.00%)_Space_17.94_MB_(73.46%)
 
+from typing import Optional
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):

src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution0114_test.py

@@ -0,0 +1,47 @@
+import unittest
+from Solution0114 import Solution, TreeNode
+
+def build_tree(values):
+    if not values:
+        return None
+    root = TreeNode(values[0])
+    queue = [root]
+    i = 1
+    while queue and i < len(values):
+        node = queue.pop(0)
+        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
+
+def flatten_to_list(root):
+    result = []
+    current = root
+    while current:
+        result.append(current.val)
+        current = current.right
+    return result
+
+
+class SolutionTest(unittest.TestCase):
+    def test_flatten(self):
+        root = build_tree([1, 2, 5, 3, 4, None, 6])
+        Solution().flatten(root)
+        expected = [1, 2, 3, 4, 5, 6]
+        self.assertEqual(flatten_to_list(root), expected)
+
+    def test_flatten2(self):
+        root = build_tree([])
+        Solution().flatten(root)
+        self.assertIsNone(root)
+
+    def test_flatten3(self):
+        root = build_tree([0])
+        Solution().flatten(root)
+        expected = [0]
+        self.assertEqual(flatten_to_list(root), expected)

src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/Solution0121.py

@@ -3,6 +3,8 @@
 # #Top_Interview_150_Array/String #Big_O_Time_O(N)_Space_O(1)
 # #2025_07_25_Time_17_ms_(98.03%)_Space_26.89_MB_(77.51%)
 
+from typing import List
+
 class Solution:
     def maxProfit(self, prices: List[int]) -> int:
         min_price = float('inf')

src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/Solution0121_test.py

@@ -0,0 +1,12 @@
+import unittest
+from Solution0121 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_maxProfit(self):
+        self.assertEqual(Solution().maxProfit([7,1,5,3,6,4]), 5)
+
+    def test_maxProfit2(self):
+        self.assertEqual(Solution().maxProfit([7,6,4,3,1]), 0)
+
+    def test_maxProfit3(self):
+        self.assertEqual(Solution().maxProfit([1]), 0)

src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution0124.py

@@ -2,6 +2,13 @@
 # #Tree #Binary_Tree #Udemy_Tree_Stack_Queue #Top_Interview_150_Binary_Tree_General
 # #Big_O_Time_O(N)_Space_O(N) #2025_07_25_Time_11_ms_(91.40%)_Space_22.92_MB_(80.36%)
 
+from typing import Optional
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):

src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution0124_test.py

@@ -0,0 +1,33 @@
+import unittest
+from Solution0124 import Solution, TreeNode
+
+def build_tree(values):
+    if not values:
+        return None
+    root = TreeNode(values[0])
+    queue = [root]
+    i = 1
+    while queue and i < len(values):
+        node = queue.pop(0)
+        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
+
+class SolutionTest(unittest.TestCase):
+    def test_maxPathSum(self):
+        root = build_tree([1, 2, 3])
+        self.assertEqual(Solution().maxPathSum(root), 6)
+
+    def test_maxPathSum2(self):
+        root = build_tree([-10, 9, 20, None, None, 15, 7])
+        self.assertEqual(Solution().maxPathSum(root), 42)
+
+    def test_maxPathSum3(self):
+        root = build_tree([-3])
+        self.assertEqual(Solution().maxPathSum(root), -3)