def repeated_word(str): tree = BinarySearchTree() array = str.split(' ') node = Node(array[0]) tree.root = node curr = tree.root def _check(curr, node): if node.data == curr.data: return curr.data if node.data < curr.data: if not curr.left: curr.left = node else: return _check(curr.left, node) if node.data > curr.data: if not curr.right: curr.right = node else: return _check(curr.right, node) return False result = False for i in range(1, len(array)): node = Node(array[i]) result = _check(curr, node) if result is not False: break return result
def test_add_right_and_left(): tree = BinaryTree() tree.root = Node(10) tree.root.left = Node(3) tree.root.right = Node(15) actual = f"{tree.root.value}, {tree.root.left.value}, {tree.root.right.value}" expected = "10, 3, 15" assert actual == expected
def test_2(self): node = Node(1, None, None) node.left = Node(2, Node(4, None, None), Node(5, None, None)) node.right = Node(3, Node(6, None, None), Node(7, None, None)) t = Tree(node) assert t.print_tree() == [['|', '|', '|', '1', '|', '|', '|'], ['|', '2', '|', '|', '|', '3', '|'], ['4', '|', '5', '|', '6', '|', '7']]
def test4(self): d = Node(4, None, None) e = Node(2, None, None) b = Node(9, None, d) c = Node(6, e, None) a = Node(7, b, c) tree4 = Tree(a) assert tree4.print_tree() == self.answer4
def test_case_2(self): node = Node(1, Node(2, Node(3, Node(4, None, None), None), None), None) self.tree = Tree(node) self.answer = [['|', '|', '|', '|', '|', '|', '|', 1, '|', '|', '|', '|', '|', '|', '|'], ['|', '|', '|', 2, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 3, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], [4, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|']] assert self.tree.print_tree() == self.answer
def test_printtree(self): a = Node(1, Node(2, Node(4, None, None), None), Node(3, None, None)) b = Tree(a) res = [['|', '|', '|', '1', '|', '|', '|'], ['|', '2', '|', '|', '|', '3', '|'], ['4', '|', '|', '|', '|', '|', '|']] assert res == b.printTree(a)
def test_add_left_and_right(): tree = BinaryTree() tree.root = Node(111) tree.left = Node(11) tree.right = Node(1) actual = f"{tree.root.value}, {tree.left.value}, {tree.right.value}" expected = "111, 11, 1" assert actual == expected
def test_can_successfully_add_a_left_child_and_right_child_to_a_single_root_node(): new_tree = BinaryTree() new_tree.root = Node(1) new_tree.root.left = Node(2) new_tree.root.right = Node(3) expected = [1, 2, 3] actual = new_tree.preOrder() assert expected == actual
def tree_test_two(): node1 = Node(1) node1.left = Node(2) node1.left.right = Node(7) node1.left.left = Node(9) node1.right = Node(3) node1.right.left = Node(4) node1.right.right = Node(5) bts = BinarySearchTree(node1) return bts
def tree_test(): node1 = Node(1) node1.left = Node(2) node1.left.right = Node(7) node1.left.left = Node(9) node1.right = Node(3) node1.right.left = Node(4) node1.right.right = Node(5) binary_tree = BinaryTree(node1) return binary_tree
def test_postorder(): tree = BinaryTree() tree.root = Node(50) tree.root.left = Node(30) tree.root.right = Node(70) tree.root.left.left = Node(20) tree.root.left.right = Node(40) actual = tree.post_order() expected = [20, 40, 30, 70, 50] assert actual == expected
def test_tree_preorder(): tree = BinaryTree() tree.root = Node(1) tree.root.left = Node(11) tree.root.right = Node(111) tree.root.left.left = Node(1111) tree.root.left.right = Node(11111) actual = tree.pre_order() expected = [1, 11, 1111, 11111, 111] assert actual == expected
def test_2(self): a_2 = Node(1) b_2 = Node(2) c_2 = Node(3) d_2 = Node(4) a_2.left = b_2 b_2.left = c_2 c_2.left = d_2 tree_2 = Btree(a_2) assert tree_2.pring() == self.answer_2
def test_3(self): a_3 = Node(1) b_3 = Node(2) c_3 = Node(3) d_3 = Node(4) a_3.left = b_3 b_3.right = c_3 c_3.left = d_3 tree_3 = Btree(a_3) assert tree_3.pring() == self.answer_3
def test_tree_postorder(): tree = BinaryTree() tree.root = Node(1) tree.root.left = Node(11) tree.root.right = Node(2) tree.root.left.left = Node(111) tree.root.left.right = Node(112) actual = tree.post_order() expected = [111, 112, 11, 2, 1] assert actual == expected
def test_tree_inorder(): tree = BinaryTree() tree.root = Node(1) tree.root.left = Node(11) tree.root.right = Node(2) tree.root.left.left = Node(111) tree.root.right.right = Node(22) actual = tree.in_order() expected = [111, 11, 1, 2, 22] assert actual == expected
def test_two_duplicate_strings(): binarytree1, binarytree2 = BinaryTreeSearch(), BinaryTreeSearch() binarytree1.root.value = "cat" binarytree1.root.right_node = Node("dog") binarytree1.root.left_node = Node("unicorn") binarytree1.root.value = "horse" binarytree1.root.right_node = Node("dog") binarytree1.root.left_node = Node("unicorn") binarytree1.root.left_node.left_node = Node("cat") actual = tree_intersection(binarytree1, binarytree2) expected = ["cat", "dog"] assert actual == expected
def test_find_max_value_within_tree(): test_node = Node(1) test_node.left = Node(2) test_node.right = Node(3) test_node.left.left = Node(4) test_node.left.right = Node(5) test_node.right.left = Node(6) test_node.right.right = Node(7) test_tree = BinaryTree(test_node) expected = 7 actual = test_tree.find_maximum_value() assert actual == expected
def test_breadth_first(): test_node = Node(1) test_node.left = Node(2) test_node.right = Node(3) test_node.left.left = Node(4) test_node.left.right = Node(5) test_node.right.left = Node(6) test_node.right.right = Node(7) test_tree = BinaryTree(test_node) actual = test_tree.breadth_first() expected = [1, 2, 3, 4, 5, 6, 7] assert actual == expected
def test_dupes_tree2(): tree2 = BinaryTree() #tree2 tree2.root = Node(1) #left tree2.root.left = Node(3) tree2.root.left.left = Node(15) tree2.root.left.right = Node(12) tree2.root.left.right.left = Node(15) # right tree2.root.right = Node(20) tree2.root.right.left = Node(23) tree2.root.right.right = Node(11) tree2.root.right.right.left = Node(2) tree2.root.right.right.right = Node(12) return tree2
def test_get_tree_list1(self): """ Test a single node tree :return: """ a = Node(1, None, None) tree1 = Tree(a) assert tree1.get_tree_list(a) == ['1']
def test_dupes_tree1(): tree1 = BinaryTree() #tree1 tree1.root = Node(1) #left tree1.root.left = Node(1) tree1.root.left.left = Node(5) tree1.root.left.right = Node(10) tree1.root.left.right.left = Node(5) # right tree1.root.right = Node(20) tree1.root.right.left = Node(2) tree1.root.right.right = Node(14) tree1.root.right.right.left = Node(2) tree1.root.right.right.right = Node(100) return tree1
def test_2(self): self.test = Node(1, Node(2, Node(3, None, None), Node(4, None, None)), Node(5, Node(6, None, None), Node(7, None, None))) self.answer = [['|', '|', '|', 1, '|', '|', '|'], ['|', 2, '|', '|', '|', 5, '|'], [3, '|', 4, '|', 6, '|', 7]] assert Tree(self.test).printTree() == self.answer
def test3(self): # all branches on the left case3 = Node(1, Node(2, Node(None, None, None), Node(5, None, None)), Node(3, Node(4, None, None), Node(None, None, None))) self.input = Tree.PrintTree(case3) self.answer = "|||1|||\n|2|||3|\n||5|4||\n" assert self.input == self.answer
def test2(self): # full balanced tree case2 = Node(1, Node(2, Node(4, None, None), Node(5, None, None)), Node(3, Node(6, None, None), Node(7, None, None))) self.input = Tree.PrintTree(case2) self.answer = "|||1|||\n|2|||3|\n4|5|6|7\n" assert self.input == self.answer
def test_instantiate_tree(): tree = BinaryTree() tree.root = Node(2) tree.root.left = Node(7) tree.root.left.left = Node(2) tree.root.left.right = Node(6) tree.root.left.right.left = Node(5) tree.root.left.right.right = Node(11) tree.root.right = Node(5) tree.root.right.right = Node(9) tree.root.right.right.left = Node(4) actual = tree.find_maximum_value() expected = 11 assert actual == expected
def test_adding(): test_tree = BinarySearchTree(Node(1)) test_tree.add(2) test_tree.add(3) test_tree.add(4) test_tree.add(5) actual = test_tree.inOrder() expected = [1, 2, 3, 4, 5] assert actual == expected
def binary_tree(): tree = BinaryTree() tree.root = Node(1) tree.root.left = Node(5) tree.root.right = Node(10) tree.root.left.right = Node(25) tree.root.left.right.left = Node(13) tree.root.left.right.right = Node(15) tree.root.right.right = Node(9) tree.root.right.right.left = Node(4) return tree
def binary_tree3(): tree3 = BinaryTree() tree3.root = Node(2) tree3.root.left = Node(18) tree3.root.right = Node(6) tree3.root.left.right = Node(8) tree3.root.left.right.left = Node(20) tree3.root.left.right.right = Node(12) tree3.root.right.right = Node(14) tree3.root.right.right.left = Node(16) return tree3
def test_case_3(self): node = Node(1, Node(2, Node(4, None, None), Node(5, None, None)), Node(3, Node(6, None, None), Node(7, None, None))) self.tree = Tree(node) self.answer = [['|', '|', '|', 1, '|', '|', '|'], ['|', 2, '|', '|', '|', 3, '|'], [4, '|', 5, '|', 6, '|', 7]] assert self.tree.print_tree() == self.answer
return None if node.right: in_order(node.right) return None def post_order(node): if node.left: post_order(node.left) if node.right: post_order(node.right) if node.value: print node.value return None if __name__ == "__main__": root = Node(None, "F") B = root.add_left_child("B") A = B.add_left_child("A") D = B.add_right_child("D") C = D.add_left_child("C") E = D.add_right_child("E") G = root.add_right_child("G") I = G.add_right_child("I") H = I.add_left_child("H") print "Pre-order depth first:" pre_order(root) print "In-order depth first:" in_order(root) print "Post-order depth first:" post_order(root)