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