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 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
"""