def postorder(tree: BinaryTree): """ Aka 'backward order'. In a postorder traversal, we recursively do a postorder traversal of the left subtree and the right subtree followed by a visit to the root node. """ if tree: postorder(tree.get_left_child()) postorder(tree.get_right_child()) print(tree.get_root_value())
def preorder(tree: BinaryTree): """ Aka 'forward order'. In a preorder traversal, we visit the root node first, then recursively do a preorder traversal of the left subtree, followed by a recursive preorder traversal of the right subtree. """ if tree: print(tree.get_root_value()) preorder(tree.get_left_child()) preorder(tree.get_right_child())
def inorder(tree: BinaryTree): """ Aka 'symmetric order'. In an inorder traversal, we recursively do an inorder traversal on the left subtree, visit the root node, and finally do a recursive inorder traversal of the right subtree. """ if tree: inorder(tree.get_left_child()) print(tree.get_root_value()) inorder(tree.get_right_child())
def exp_tree(): exp = BinaryTree('+') exp.add_child('+', '*') exp.add_child('+', 'e') exp.add_child('*', 'c') exp.add_child('*', '+') exp.add_child('+', 'd') exp.add_child('+', 'g') print("Recorrido en preorden", exp.preorder())
def buildParseTree(fpexp): fplist = fpexp.split() pStack = list() eTree = BinaryTree('') pStack.append(eTree) currentTree = eTree for i in fplist: if i == '(': currentTree.insert_left('') pStack.append(currentTree) currentTree = currentTree.get_left_child() elif i.isdigit(): currentTree.set_root_value(int(i)) parent = pStack.pop() currentTree = parent elif i in ['+', '-', '*', '/']: currentTree.set_root_value(i) currentTree.insert_right('') pStack.append(currentTree) currentTree = currentTree.get_right_child() elif i == ')': currentTree = pStack.pop() else: raise ValueError return eTree
def test_list_of_depths_returns_hashmap_of_2_linked_lists_for_a_tree_with_2_depth_levels( self): node1 = BinaryTreeNode.new(data=1) node2 = BinaryTreeNode.new(data=2, parent=node1) node3 = BinaryTreeNode.new(data=3, parent=node1) node1.set_left_child(node2) node1.set_right_child(node3) tree = BinaryTree.new(root=node1) linked_lists_hashmap = list_of_depths(binary_tree=tree) self.assertTrue(linked_lists_hashmap[0]) self.assertTrue(linked_lists_hashmap[1]) self.assertEqual(linked_lists_hashmap[0].head().data(), node1) self.assertEqual(linked_lists_hashmap[1].head().data(), node2) self.assertEqual(linked_lists_hashmap[1].tail().data(), node3)
def get_vertical_order(root, hd, mapping): if not root: return if hd not in mapping: mapping[hd] = [] mapping[hd].append(root.key) get_vertical_order(root.left, hd-1, mapping) get_vertical_order(root.right, hd+1, mapping) def print_vertical_order(mapping): for key in sorted(mapping.iterkeys()): for val in mapping[key]: print(val), print mapping = {} tree = BinaryTree(1) tree.add_left(tree.root, 2) tree.add_right(tree.root, 3) tree.add_left(tree.root.left, 4) tree.add_right(tree.root.right, 5) get_vertical_order(tree.root, hd=0, mapping=mapping) print_vertical_order(mapping)
from trees.binary_tree import BinaryTree from dynamic_programming.maximum_path.tree import tree_top_down from dynamic_programming.maximum_path.triangle_graph import triangle_top_down, triangle_top_down_with_cache from dynamic_programming.maximum_path.triangle_graph import triangle_bottom_up import copy print('############################') print('Testing top_down') print('############################') tree = BinaryTree([2, 4, 2, 67, 3, 3, 6, 9, 7]) tree.prettyPrint() assert tree_top_down(tree._root) == 83 print('############################') print('Testing triangle_top_down') print('############################') triangle = [[1], [2, 3], [4, 2, 5], [5, 1, 9, 2]] assert triangle_top_down(triangle) == 9 + 5 + 3 + 1 triangle.append([13, 1, 1, 1, 1]) assert triangle_top_down(triangle) == 13 + 5 + 4 + 2 + 1 print('############################') print('Testing triangle_top_down_with_cache') print('############################')
def setUp(self): self.root = BinaryTree(0)
class TestBinaryTree(unittest.TestCase): def setUp(self): self.root = BinaryTree(0) def tearDown(self): self.root = None def test_init_root(self): self.assertEqual(None, self.root.parent) def test_add_right(self): self.root.value = 5 self.root.add(10) self.assertEqual(10, self.root.right.value) def test_add_left(self): self.root.value = 5 self.root.add(1) self.assertEqual(1, self.root.left.value) def test_add_right_parent(self): self.root.value = 5 self.root.add(10) self.assertEqual(self.root, self.root.right.parent) def test_add_left_parent(self): self.root.value = 5 self.root.add(1) self.assertEqual(self.root, self.root.left.parent) def test_add_two_right(self): self.root.value = 5 self.root.add(10) self.root.add(15) self.assertEqual(10, self.root.right.value) self.assertEqual(15, self.root.right.right.value) def test_add_two_left(self): self.root.value = 5 self.root.add(3) self.root.add(1) self.assertEqual(3, self.root.left.value) self.assertEqual(1, self.root.left.left.value) def test_add_two_right_one_nested_left(self): self.root.value = 5 self.root.add(10) self.root.add(15) self.root.add(13) self.assertEqual(13, self.root.right.right.left.value) def test_add_two_left_one_nested_right(self): self.root.value = 15 self.root.add(10) self.root.add(3) self.root.add(7) self.assertEqual(7, self.root.left.left.right.value) def test_search_for_simple_right(self): self.root.value = 10 self.root.add(15) self.assertEqual(15, self.root.search_for_value(15).value) def test_search_for_simple_left(self): self.root.value = 10 self.root.add(5) self.assertEqual(5, self.root.search_for_value(5).value) def test_search_two_left_one_nested_right(self): self.root.value = 15 self.root.add(10) self.root.add(3) self.root.add(7) self.assertEqual(3, self.root.search_for_value(3).value) def test_delete_left_leaf(self): self.root.value = 10 self.root.add(5) tree_to_remove = self.root.search_for_value(5) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 5) def test_delete_right_leaf(self): self.root.value = 10 self.root.add(15) tree_to_remove = self.root.search_for_value(15) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 15) def test_delete_right_one_branch(self): self.root.value = 10 self.root.add(15) self.root.add(20) tree_to_remove = self.root.search_for_value(15) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 15) def test_delete_left_one_branch(self): self.root.value = 10 self.root.add(5) self.root.add(3) tree_to_remove = self.root.search_for_value(5) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 5) def test_delete_right_two_branches(self): self.root.value = 10 self.root.add(15) self.root.add(20) self.root.add(12) tree_to_remove = self.root.search_for_value(15) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 15) self.assertEqual(12, self.root.right.left.value) self.assertEqual(20, self.root.right.value) def test_delete_left_two_branches(self): self.root.value = 10 self.root.add(5) self.root.add(3) self.root.add(7) tree_to_remove = self.root.search_for_value(5) self.root.delete(tree_to_remove) self.assertRaises(ValueError, self.root.search_for_value, 5) self.assertEqual(3, self.root.left.left.value) self.assertEqual(7, self.root.left.value) def test_max_depth_0(self): self.root.value = 10 self.assertEqual(0, self.root.max_depth()) def test_max_depth_1(self): self.root.value = 10 self.root.add(5) self.assertEqual(1, self.root.max_depth()) self.root.add(13) self.assertEqual(1, self.root.max_depth()) def test_max_depth_2(self): self.root.value = 10 self.root.add(5) self.root.add(3) self.assertEqual(2, self.root.max_depth()) def test_max_depth_2_nested(self): self.root.value = 10 self.root.add(5) self.root.add(7) self.assertEqual(2, self.root.max_depth()) def test_max_depth_3(self): self.root.value = 10 self.root.add(5) self.root.add(3) self.root.add(1) self.assertEqual(3, self.root.max_depth()) def test_max_depth_3_nested_left(self): self.root.value = 10 self.root.add(5) self.root.add(7) self.root.add(9) self.assertEqual(3, self.root.max_depth()) def test_max_depth_3_nested_right(self): self.root.value = 10 self.root.add(12) self.root.add(15) self.root.add(11) self.root.add(16) self.assertEqual(3, self.root.max_depth())
def test_binary_tree(): bt = BinaryTree() bt.add_child(None, 'A') print(bt.add_child('A', 'B')) print(bt.add_child('A', 'C')) print(bt.add_child('B', 'D')) print(bt.add_child('B', 'E')) print(bt.add_child('D', 'H')) print(bt.add_child('E', 'I')) print(bt.add_child('E', 'J')) print(bt.add_child('C', 'F')) print(bt.add_child('C', 'G')) print("Recorrido en preorden: ", bt.preorder()) print("Recorrido en postorden: ", bt.postorder()) print("Recorrido en entreorden: ", bt.inorder()) print("Recorrido a lo ancho:", bt.bfs())
def postorder(tree: BinaryTree): """ Aka 'backward order'. In a postorder traversal, we recursively do a postorder traversal of the left subtree and the right subtree followed by a visit to the root node. """ if tree: postorder(tree.get_left_child()) postorder(tree.get_right_child()) print(tree.get_root_value()) if __name__ == '__main__': bt = BinaryTree('0') bt.insert_left('1') bt.insert_right('2') left = bt.get_left_child() right = bt.get_right_child() left.insert_left('1.1') left.insert_right('1.2') right.insert_left('2.1') right.insert_right('2.2') """ Tree representation: ___0___ / \ 1 2 / \ / \ 1.1 1.2 2.1 2.2 """