From ebdae46efdc28640ec34f8d6c21bb1c92a8d8cc1 Mon Sep 17 00:00:00 2001 From: "staging-devin-ai-integration[bot]" <166158716+staging-devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 22 Aug 2024 18:43:13 +0000 Subject: [PATCH 1/5] Add binary tree traversal algorithm with tests --- tree/binary_tree_traversal.py | 54 ++++++++++++++++++++++++++++++ tree/test_binary_tree_traversal.py | 37 ++++++++++++++++++++ 2 files changed, 91 insertions(+) create mode 100644 tree/binary_tree_traversal.py create mode 100644 tree/test_binary_tree_traversal.py diff --git a/tree/binary_tree_traversal.py b/tree/binary_tree_traversal.py new file mode 100644 index 0000000..bb70d0e --- /dev/null +++ b/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)) diff --git a/tree/test_binary_tree_traversal.py b/tree/test_binary_tree_traversal.py new file mode 100644 index 0000000..832d5c6 --- /dev/null +++ b/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() From 54a9b3aded588afef6cd6a72f6c0bbc1b1fbe1a8 Mon Sep 17 00:00:00 2001 From: "staging-devin-ai-integration[bot]" <166158716+staging-devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 22 Aug 2024 18:53:36 +0000 Subject: [PATCH 2/5] Implement inorder traversal algorithm as a placeholder for new tree algorithm --- tree/binary_tree/new_tree_algorithm.py | 37 ++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 tree/binary_tree/new_tree_algorithm.py diff --git a/tree/binary_tree/new_tree_algorithm.py b/tree/binary_tree/new_tree_algorithm.py new file mode 100644 index 0000000..708f47c --- /dev/null +++ b/tree/binary_tree/new_tree_algorithm.py @@ -0,0 +1,37 @@ +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 implements an inorder traversal algorithm. + + Args: + root (TreeNode): The root node of the binary tree. + + Returns: + list: The inorder traversal of the binary tree. + """ + def inorder_traversal(node, result): + if node: + inorder_traversal(node.left, result) + result.append(node.val) + inorder_traversal(node.right, result) + + result = [] + inorder_traversal(root, result) + return result + +# 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"Inorder traversal of the binary tree: {result}") From 6dec81fc95f52e17cb9b58dfc4d0ec37418c7768 Mon Sep 17 00:00:00 2001 From: "staging-devin-ai-integration[bot]" <166158716+staging-devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 22 Aug 2024 19:00:11 +0000 Subject: [PATCH 3/5] Implement novel tree algorithm to calculate sum of nodes at each level --- tree/binary_tree/new_tree_algorithm.py | 33 +++++++++++++++++--------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/tree/binary_tree/new_tree_algorithm.py b/tree/binary_tree/new_tree_algorithm.py index 708f47c..bac5787 100644 --- a/tree/binary_tree/new_tree_algorithm.py +++ b/tree/binary_tree/new_tree_algorithm.py @@ -6,23 +6,34 @@ def __init__(self, val=0, left=None, right=None): def new_tree_algorithm(root): """ - This function implements an inorder traversal algorithm. + 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: The inorder traversal of the binary tree. + list: A list where each element is the sum of node values at the corresponding level. """ - def inorder_traversal(node, result): - if node: - inorder_traversal(node.left, result) - result.append(node.val) - inorder_traversal(node.right, result) + if not root: + return [] - result = [] - inorder_traversal(root, result) - return result + 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__": @@ -34,4 +45,4 @@ def inorder_traversal(node, result): root.left.right = TreeNode(5) result = new_tree_algorithm(root) - print(f"Inorder traversal of the binary tree: {result}") + print(f"Sum of nodes at each level: {result}") From 7cb4355bf0fb2256ec74e57cd42164f7c936bc18 Mon Sep 17 00:00:00 2001 From: "staging-devin-ai-integration[bot]" <166158716+staging-devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 22 Aug 2024 19:01:13 +0000 Subject: [PATCH 4/5] Implement DFS traversal algorithm for binary tree --- tree/new_tree_algorithm.py | 51 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 tree/new_tree_algorithm.py diff --git a/tree/new_tree_algorithm.py b/tree/new_tree_algorithm.py new file mode 100644 index 0000000..a7211b6 --- /dev/null +++ b/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() From 8fa5f7b7e79ba6b9832b81f1f255e4c2347ac2e1 Mon Sep 17 00:00:00 2001 From: "staging-devin-ai-integration[bot]" <166158716+staging-devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 23 Aug 2024 16:11:16 +0000 Subject: [PATCH 5/5] Address PR comments: Update TreeNode class, remove new_tree_algorithm function, refactor code --- tree/binary_tree/new_tree_algorithm.py | 88 +++++++++++++------------- 1 file changed, 45 insertions(+), 43 deletions(-) diff --git a/tree/binary_tree/new_tree_algorithm.py b/tree/binary_tree/new_tree_algorithm.py index bac5787..0b2143a 100644 --- a/tree/binary_tree/new_tree_algorithm.py +++ b/tree/binary_tree/new_tree_algorithm.py @@ -1,48 +1,50 @@ class TreeNode: - def __init__(self, val=0, left=None, right=None): - self.val = val - self.left = left - self.right = right + def __init__(self, value): + self.value = value + self.left = None + self.right = None -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 +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__": - # 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 = BinaryTree() + tree.insert(5) + tree.insert(3) + tree.insert(7) + tree.insert(1) + tree.insert(9) + + # Perform DFS traversal + tree.dfs_traversal()