Add Binary Tree Traversal Algorithm

tree/binary_tree/new_tree_algorithm.py

@@ -0,0 +1,50 @@
+class TreeNode:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+class BinaryTree:
+    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 dfs_traversal(self):
+        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 = BinaryTree()
+    tree.insert(5)
+    tree.insert(3)
+    tree.insert(7)
+    tree.insert(1)
+    tree.insert(9)
+
+    # Perform DFS traversal
+    tree.dfs_traversal()

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()