feat(data-structures, binary-tree): mirror binary tree

Author: BrianLusina

algorithms/sliding_window/max_sum_of_subarray/__init__.py

@@ -10,7 +10,7 @@ def max_sum_subarray(nums: List[int], k: int) -> int:
 
     start = 0
     state = 0
-    max_sum = float('-inf')
+    max_sum = float("-inf")
 
     for end in range(n):
         state += nums[end]

datastructures/trees/binary/test_utils.py

@@ -6,8 +6,13 @@
     lowest_common_ancestor_ptr,
     connect_all_siblings,
     connect_all_siblings_ptr,
+    mirror_binary_tree,
 )
 from datastructures.trees.binary.node import BinaryTreeNode
+from datastructures.trees.binary.tree.tree_utils import (
+    create_tree_from_nodes,
+    level_order_traversal,
+)
 
 
 class LowestCommonAncestorTestCase(unittest.TestCase):
@@ -222,5 +227,25 @@ def test_connect_all_siblings_ptr(self, root: BinaryTreeNode, expected: List[int
         self.assertIsNone(current)
 
 
+MIRROR_BINARY_TREE_TEST_CASES = [
+    ([100, 50, 200, 25, 75, 125, 350], [100, 200, 50, 350, 125, 75, 25]),
+    ([1, 2, None, 3, None, 4], [1, None, 2, None, 3, None, 4]),
+    ([25, 50, 75, 100, 125, 350], [25, 75, 50, None, 350, 125, 100]),
+    ([100], [100]),
+    ([4, 2, 7, 1, 3, 6, 9], [4, 7, 2, 9, 6, 3, 1]),
+    ([], []),
+    ([2, 1, 3], [2, 3, 1]),
+]
+
+
+class MirrorBinaryTreeTestCase(unittest.TestCase):
+    @parameterized.expand(MIRROR_BINARY_TREE_TEST_CASES)
+    def test_mirror_binary_tree(self, data: List[int], expected: List[int]):
+        root = create_tree_from_nodes(data)
+        actual = mirror_binary_tree(root)
+        actual_data = level_order_traversal(actual)
+        self.assertEqual(expected, actual_data)
+
+
 if __name__ == "__main__":
     unittest.main()

datastructures/trees/binary/tree/README.md

@@ -391,3 +391,65 @@ Constraints:
 ![Example 1](./images/examples/minimum_camera_cover_binary_tree_example_1.png)
 ![Example 2](./images/examples/minimum_camera_cover_binary_tree_example_2.png)
 ![Example 3](./images/examples/minimum_camera_cover_binary_tree_example_3.png)
+
+---
+
+## Invert Binary Tree
+
+Given the root node of a binary tree, transform the tree by swapping each node’s left and right subtrees, thus creating
+a mirror image of the original tree. Return the root of the transformed tree.
+
+### Constraints
+
+- 0 <= `Number of nodes in the tree` <= 100
+- -1000 <= `node.value` <= 1000
+
+### Examples
+
+![Example 1](./images/examples/mirror_binary_tree_example_1.png)
+![Example 2](./images/examples/mirror_binary_tree_example_2.png)
+![Example 3](./images/examples/mirror_binary_tree_example_3.png)
+
+### Solution
+
+For this solution, we do a post-order (left, right, parent) traversal of the binary tree. The algorithm is as follows:
+
+- Perform post-order traversal on the left child of the root node.
+- Perform post-order traversal on the right child of the root node.
+- Swap the left and right children of the root node.
+
+Since we perform a depth-first search traversal, the children of any node are already mirrored even before we return the
+node itself.
+
+Let’s look at an example below:
+
+> Note: In this example, the node at the top of the stack is the current node.
+
+![Solution 1](./images/solutions/mirror_binary_tree_solution_1.png)
+![Solution 2](./images/solutions/mirror_binary_tree_solution_2.png)
+![Solution 3](./images/solutions/mirror_binary_tree_solution_3.png)
+![Solution 4](./images/solutions/mirror_binary_tree_solution_4.png)
+![Solution 5](./images/solutions/mirror_binary_tree_solution_5.png)
+![Solution 6](./images/solutions/mirror_binary_tree_solution_6.png)
+![Solution 7](./images/solutions/mirror_binary_tree_solution_7.png)
+![Solution 8](./images/solutions/mirror_binary_tree_solution_8.png)
+![Solution 9](./images/solutions/mirror_binary_tree_solution_9.png)
+![Solution 10](./images/solutions/mirror_binary_tree_solution_10.png)
+![Solution 11](./images/solutions/mirror_binary_tree_solution_11.png)
+![Solution 12](./images/solutions/mirror_binary_tree_solution_12.png)
+![Solution 13](./images/solutions/mirror_binary_tree_solution_13.png)
+![Solution 14](./images/solutions/mirror_binary_tree_solution_14.png)
+![Solution 15](./images/solutions/mirror_binary_tree_solution_15.png)
+![Solution 16](./images/solutions/mirror_binary_tree_solution_16.png)
+
+#### Time Complexity
+
+The time complexity of this solution is linear O(n), where n is the number of nodes in the tree.
+
+> Note:  Every subtree needs to be mirrored, so we visit every node once. Because of that, the runtime complexity is O(n).
+
+#### Space Complexity
+
+The space complexity of this solution is O(h), where h is the height of the tree. This is because our recursive
+algorithm uses space on the call stack, which can grow to the height of the binary tree. The complexity will be O(log(n))
+for a balanced tree and O(n) for a degenerate tree.

datastructures/trees/binary/tree/binary_tree.py

@@ -912,3 +912,24 @@ def dfs(node: BinaryTreeNode):
             camera_count[0] += 1
 
         return camera_count[0]
+
+    def invert_tree(self) -> Optional[BinaryTreeNode]:
+        """
+        Inverts this binary tree by swapping each node's left and right subtrees thus creating a mirror image of the
+        original tree
+        """
+        if not self.root:
+            return self.root
+
+        def invert_tree_helper(
+            node: Optional[BinaryTreeNode],
+        ) -> Optional[BinaryTreeNode]:
+            if not node:
+                return node
+
+            inverted_left = invert_tree_helper(node.left)
+            inverted_right = invert_tree_helper(node.right)
+            node.left, node.right = inverted_right, inverted_left
+            return node
+
+        return invert_tree_helper(self.root)