Add Binary Tree Traversal Algorithm

tree/binary_tree/new_tree_algorithm.py

@@ -0,0 +1,48 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def new_tree_algorithm(root):
+    """
+    This function calculates the sum of all nodes at each level of a binary tree.
+
+    Args:
+    root (TreeNode): The root node of the binary tree.
+
+    Returns:
+    list: A list where each element is the sum of node values at the corresponding level.
+    """
+    if not root:
+        return []
+
+    level_sums = []
+    current_level = [root]
+
+    while current_level:
+        level_sum = sum(node.val for node in current_level)
+        level_sums.append(level_sum)
+
+        next_level = []
+        for node in current_level:
+            if node.left:
+                next_level.append(node.left)
+            if node.right:
+                next_level.append(node.right)
+
+        current_level = next_level
+
+    return level_sums
+
+# Example usage:
+if __name__ == "__main__":
+    # Create a sample binary tree
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.left.left = TreeNode(4)
+    root.left.right = TreeNode(5)
+
+    result = new_tree_algorithm(root)
+    print(f"Sum of nodes at each level: {result}")

tree/binary_tree_traversal.py

@@ -0,0 +1,54 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class BinaryTreeTraversal:
+    def inorder_traversal(self, root):
+        result = []
+        self._inorder(root, result)
+        return result
+
+    def _inorder(self, node, result):
+        if node:
+            self._inorder(node.left, result)
+            result.append(node.val)
+            self._inorder(node.right, result)
+
+    def preorder_traversal(self, root):
+        result = []
+        self._preorder(root, result)
+        return result
+
+    def _preorder(self, node, result):
+        if node:
+            result.append(node.val)
+            self._preorder(node.left, result)
+            self._preorder(node.right, result)
+
+    def postorder_traversal(self, root):
+        result = []
+        self._postorder(root, result)
+        return result
+
+    def _postorder(self, node, result):
+        if node:
+            self._postorder(node.left, result)
+            self._postorder(node.right, result)
+            result.append(node.val)
+
+# Example usage
+if __name__ == "__main__":
+    # Create a sample binary tree
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.left.left = TreeNode(4)
+    root.left.right = TreeNode(5)
+
+    traversal = BinaryTreeTraversal()
+
+    print("Inorder traversal:", traversal.inorder_traversal(root))
+    print("Preorder traversal:", traversal.preorder_traversal(root))
+    print("Postorder traversal:", traversal.postorder_traversal(root))

tree/new_tree_algorithm.py

@@ -0,0 +1,51 @@
+class TreeNode:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+class NewTreeAlgorithm:
+    def __init__(self):
+        self.root = None
+
+    def insert(self, value):
+        if not self.root:
+            self.root = TreeNode(value)
+        else:
+            self._insert_recursive(self.root, value)
+
+    def _insert_recursive(self, node, value):
+        if value < node.value:
+            if node.left is None:
+                node.left = TreeNode(value)
+            else:
+                self._insert_recursive(node.left, value)
+        else:
+            if node.right is None:
+                node.right = TreeNode(value)
+            else:
+                self._insert_recursive(node.right, value)
+
+    def algorithm(self):
+        # Implement Depth-First Search (DFS) traversal
+        def dfs(node):
+            if node:
+                print(node.value, end=' ')  # Visit the current node
+                dfs(node.left)              # Traverse left subtree
+                dfs(node.right)             # Traverse right subtree
+
+        print("DFS traversal:")
+        dfs(self.root)
+        print()  # Add a newline after traversal
+
+# Example usage
+if __name__ == "__main__":
+    tree = NewTreeAlgorithm()
+    tree.insert(5)
+    tree.insert(3)
+    tree.insert(7)
+    tree.insert(1)
+    tree.insert(9)
+
+    # Call and test the algorithm method
+    tree.algorithm()

tree/test_binary_tree_traversal.py

@@ -0,0 +1,37 @@
+import unittest
+from binary_tree_traversal import TreeNode, BinaryTreeTraversal
+
+class TestBinaryTreeTraversal(unittest.TestCase):
+    def setUp(self):
+        self.traversal = BinaryTreeTraversal()
+
+    def test_empty_tree(self):
+        self.assertEqual(self.traversal.inorder_traversal(None), [])
+        self.assertEqual(self.traversal.preorder_traversal(None), [])
+        self.assertEqual(self.traversal.postorder_traversal(None), [])
+
+    def test_single_node_tree(self):
+        root = TreeNode(1)
+        self.assertEqual(self.traversal.inorder_traversal(root), [1])
+        self.assertEqual(self.traversal.preorder_traversal(root), [1])
+        self.assertEqual(self.traversal.postorder_traversal(root), [1])
+
+    def test_sample_tree(self):
+        # Create a sample binary tree
+        #     1
+        #    / \
+        #   2   3
+        #  / \
+        # 4   5
+        root = TreeNode(1)
+        root.left = TreeNode(2)
+        root.right = TreeNode(3)
+        root.left.left = TreeNode(4)
+        root.left.right = TreeNode(5)
+
+        self.assertEqual(self.traversal.inorder_traversal(root), [4, 2, 5, 1, 3])
+        self.assertEqual(self.traversal.preorder_traversal(root), [1, 2, 4, 5, 3])
+        self.assertEqual(self.traversal.postorder_traversal(root), [4, 5, 2, 3, 1])
+
+if __name__ == '__main__':
+    unittest.main()