def test_problem_4_9(self):
n25 = tb.BinaryNode(25)
n70 = tb.BinaryNode(70)
n20 = tb.BinaryNode(20, right=n25)
n60 = tb.BinaryNode(60, right=n70)
n50 = tb.BinaryNode(50, left=n20, right=n60)
pass
def test_problem_4_8(self):
"""
construct binary tree
7
4 3
10 5 6 15
21 17
25
"""
n21 = tb.BinaryNode(21)
n17 = tb.BinaryNode(17)
n15 = tb.BinaryNode(15, n21, n17)
n6 = tb.BinaryNode(6)
n3 = tb.BinaryNode(3, n6, n15)
n10 = tb.BinaryNode(10)
n5 = tb.BinaryNode(5)
n4 = tb.BinaryNode(4, n10, n5)
n7 = tb.BinaryNode(7, n4, n3)
n25 = tb.BinaryNode(25) # unconnected node
self.assertEqual(n3, p_4_8.first_common_ancestor(n7, n6, n21))
self.assertEqual(n7, p_4_8.first_common_ancestor(n7, n10, n21))
self.assertEqual(None, p_4_8.first_common_ancestor(n7, n15, n25))
self.assertEqual(None, p_4_8.first_common_ancestor(n7, n7, n7)) # a node is not its own ancestor
self.assertEqual(n7, p_4_8.first_common_ancestor(n7, n3, n4))
def test_problem_4_5(self):
# construct a binary tree
node1 = tb.BinaryNode(1)
node2 = tb.BinaryNode(2)
node3 = tb.BinaryNode(3)
node4 = tb.BinaryNode(4)
node5 = tb.BinaryNode(5)
node6 = tb.BinaryNode(6)
node8 = tb.BinaryNode(8)
node10 = tb.BinaryNode(10)
"""
8
4, 10
2, 6,
1, 3, 5,
"""
node8.left = node4
node8.right = node10
node4.left = node2
node4.right = node6
node2.left = node1
node2.right = node3
node6.left = node5
self.assertTrue(p_4_5.validate_BST(node8))
# add node that breaks BST rule
node9 = tb.BinaryNode(9)
node6.right = node9
self.assertFalse(p_4_5.validate_BST(node8))
def test_problem_4_12(self):
# create tree. Same tree as in textbook.
n_11 = tb.BinaryNode(11)
n_minus_8 = tb.BinaryNode(-8)
n_minus_2 = tb.BinaryNode(-2)
n_2 = tb.BinaryNode(2)
n_1 = tb.BinaryNode(1, None, n_2)
n_3 = tb.BinaryNode(3, n_minus_8, n_minus_2)
n_minus_3 = tb.BinaryNode(-3, None, n_11)
n_5 = tb.BinaryNode(5, n_3, n_1)
n_10 = tb.BinaryNode(10, n_5, n_minus_3)
self.assertEqual(p_4_12.paths_with_sum(n_10, 8), 3)
def test_problem_4_12(self):
"""
construct binary tree like in textbook example
10
5 -3
3 1 __ 11
3 -2 __ 2
"""
# leaf nodes at depth = 3
n_3_leaf = tb.BinaryNode(3)
n_minus_2 = tb.BinaryNode(-2)
n_2 = tb.BinaryNode(2)
# nodes at depth = 2
n_3 = tb.BinaryNode(3, n_3_leaf, n_minus_2)
n_1 = tb.BinaryNode(1, None, n_2)
n_11 = tb.BinaryNode(11)
# nodes at depth = 1
n_5 = tb.BinaryNode(5, n_3, n_1)
n_minus_3 = tb.BinaryNode(-3, None, n_11)
# root node at depth = 0
n_10 = tb.BinaryNode(10, n_5, n_minus_3)
# count paths that sum to 8
self.assertEqual(p_4_12.paths_with_sum(n_10, 8), 3)
def test_problem_4_3(self):
"""
create binary tree:
10,
5,8,
1,7,_,9,
_,_,_,_,_,_,
"""
root = tb.BinaryNode(10)
n5 = tb.BinaryNode(5)
n8 = tb.BinaryNode(8)
n1 = tb.BinaryNode(1)
n7 = tb.BinaryNode(7)
n9 = tb.BinaryNode(9)
root.left = n5
root.right = n8
n5.left = n1
n5.right = n7
n8.right = n9
linked_lists = p_4_3.make_ll(root)
self.assertEqual('10,\n5,8,\n1,7,9,\n', tb.stringify_list_of_linked_lists(linked_lists))
def test_tree_binary_tree_traversals(self):
"""
8
/ \
4 10
/\ \
2 6 20
"""
n2 = tb.BinaryNode(2)
n6 = tb.BinaryNode(6)
n20 = tb.BinaryNode(20)
n4 = tb.BinaryNode(4, n2, n6)
n10 = tb.BinaryNode(10, None, n20)
n8 = tb.BinaryNode(8, n4, n10)
in_order_sequence = []
tb.in_order_traversal(n8, in_order_sequence)
self.assertEqual(in_order_sequence, [2, 4, 6, 8, 10, 20])
pre_order_sequence = []
tb.pre_order_traversal(n8, pre_order_sequence)
self.assertEqual(pre_order_sequence, [8, 4, 2, 6, 10, 20])
post_order_sequence = []
tb.post_order_traversal(n8, post_order_sequence)
self.assertEqual(post_order_sequence, [2, 6, 4, 20, 10, 8])
def test_problem_4_10(self):
# tree 1
n1_1 = tb.BinaryNode(1)
n2_1 = tb.BinaryNode(2)
n7_1 = tb.BinaryNode(7)
n9_1 = tb.BinaryNode(9)
n3_1 = tb.BinaryNode(3, n1_1, n2_1)
n8_1 = tb.BinaryNode(8, n7_1, n9_1)
n5_1 = tb.BinaryNode(5, n3_1, n8_1)
t1_head = n5_1
# tree 2
t2_head = n8_1
# tree 3
n12_3 = tb.BinaryNode(12)
n13_3 = tb.BinaryNode(13)
n11_3 = tb.BinaryNode(11, n12_3, n13_3)
t3_head = n11_3
# tree 4
n7_4 = tb.BinaryNode(7)
n9_4 = tb.BinaryNode(9)
n8_4 = tb.BinaryNode(8, n7_4, n9_4)
t4_head = n8_4
# tree 5
n6_5 = tb.BinaryNode(6)
n9_5 = tb.BinaryNode(9)
n8_5 = tb.BinaryNode(8, n6_5, n9_5)
t5_head = n8_5
self.assertEqual(p_4_10.check_subtree(t1_head, t1_head), True)
self.assertEqual(p_4_10.check_subtree(t2_head, t1_head), True)
self.assertEqual(p_4_10.check_subtree(t3_head, t1_head), False)
self.assertEqual(p_4_10.check_subtree(t4_head, t1_head), True)
self.assertEqual(p_4_10.check_subtree(t5_head, t1_head), False)
def test_problem_4_4(self):
# For the purposes of this question, a balanced tree is defined to be a tree
# such that the heights of the two subtrees of any node never differ by more than one.
"""
balanced tree:
root,
node,leaf,
leaf,leaf,_,_,
_,_,_,_,
"""
node131 = tb.BinaryNode("leaf", None, None)
node132 = tb.BinaryNode("leaf", None, None)
node121 = tb.BinaryNode("node", node131, node132)
node122 = tb.BinaryNode("leaf", None, None)
node111 = tb.BinaryNode("root", node121, node122)
self.assertTrue(p_4_4.check_balanced(node111))
"""
unbalanced tree:
root,
node,leaf,
node,leaf,_,_,
leaf,_,_,_,
_,_,
"""
node241 = tb.BinaryNode("leaf", None, None)
node231 = tb.BinaryNode("node", node241, None)
node232 = tb.BinaryNode("leaf", None, None)
node221 = tb.BinaryNode("node", node231, node232)
node222 = tb.BinaryNode("leaf", None, None)
root211 = tb.BinaryNode("root", node221, node222)
self.assertFalse(p_4_4.check_balanced(root211))
def test_problem_4_10(self):
"""
construct binary tree
7
4 3
10 5 6 15
21 17
25
"""
n21 = tb.BinaryNode(21)
n17 = tb.BinaryNode(17)
n15 = tb.BinaryNode(15, n21, n17)
n6 = tb.BinaryNode(6)
n3 = tb.BinaryNode(3, n6, n15)
n10 = tb.BinaryNode(10)
n5 = tb.BinaryNode(5)
n4 = tb.BinaryNode(4, n10, n5)
n7 = tb.BinaryNode(7, n4, n3)
n25 = tb.BinaryNode(25) # unconnected node
"""
construct disconnected binary tree
30
31 32
"""
n31 = tb.BinaryNode(31)
n32 = tb.BinaryNode(32)
n30 = tb.BinaryNode(30, n31, n32)
self.assertEqual(True, p_4_10.check_subtree(n7, n15))
self.assertEqual(True, p_4_10.check_subtree(n7, n7))
self.assertEqual(True, p_4_10.check_subtree(n7, n21))
self.assertEqual(True, p_4_10.check_subtree(n7, n4))
self.assertEqual(False, p_4_10.check_subtree(n7, None))
self.assertEqual(False, p_4_10.check_subtree(n7, n30))
self.assertEqual(False, p_4_10.check_subtree(n4, n31))
self.assertEqual(False, p_4_10.check_subtree(n25, n31))
self.assertEqual(True, p_4_10.check_subtree(n30, n31))
self.assertEqual(False, p_4_10.check_subtree(None, None))
