def test_from_array_representation(self): bst = BinarySearchTree.from_array_representation([]) self.assertEqual(bst, self.empty_bst) array = binarytree.bst(height=random.randint(0, 9), is_perfect=random.choice([True, False])).values bst = BinarySearchTree.from_array_representation(array) self.assertEqual(array, bst.to_array_representation())
def test_depth_first_search(self): bst = BinarySearchTree(5, "apple") bst.insert(2, "banana") bst.insert(7, "orange") bst.insert(8, "tomato") node = bst.insert(6, "carrot") result = bst.depth_first_search("carrot") assert node is result node = bst.depth_first_search("hello") assert node is None
def test_reconstruct_tree(self): serialized_tree = self.tree.serialize() inorder_lst, preorder_lst = serialized_tree['inorder'], serialized_tree['preorder'] reconstructed_tree = BinarySearchTree.deserialize(inorder_lst, preorder_lst) inorder_order = [1, 2, 3, 4, 5, 6, 7] for i, node in enumerate(inorder(reconstructed_tree.root)): assert_that(inorder_order[i]).is_equal_to(node.value)
def test_init(self): """Initializes with a root node; raises an error for empty key.""" bst = BinarySearchTree(1, "value") assert bst.root.key == 1 assert bst.root.value == "value" assert_raises(KeyError, BinarySearchTree, None, None) assert_raises(KeyError, BinarySearchTree, "string", None)
def test_return_postorder_traversal(): bst = BinarySearchTree() bst.add(3) bst.add(2) bst.add(6) actual = bst.post_order() expected = [2, 6, 3] assert actual == expected
def test_return_inorder_traversal(): bst = BinarySearchTree() bst.add(3) bst.add(2) bst.add(6) actual = bst.in_order() expected = [2, 3, 6] assert actual == expected
def test_return_preorder_traversal(): bst = BinarySearchTree() bst.add(3) bst.add(2) bst.add(6) actual = bst.pre_order() expected = [3, 2, 6] assert actual == expected
def test__eq__(self): tree_1 = BinarySearchTree() for i in self.insert_items: tree_1.insert(i) self.assertEqual(self.bst, tree_1) tree_2 = BinarySearchTree() for i in [1, 2, 3]: tree_2.insert(i) self.assertNotEqual(self.bst, tree_2) self.assertNotEqual(self.bst, self.empty_bst)
def test_right_rotate(self): bst = BinarySearchTree(5) bst.insert(6) node = bst.insert(4) bst.right_rotate(bst.root) assert bst.root is node assert bst.root.right.key == 5 assert bst.root.right.right.key == 6
def test_search(self): bst = BinarySearchTree(1, "value") bst.insert(2, "another value") rightmost_node = bst.insert(3, "final value") node = bst.search(3) assert node is rightmost_node assert_raises(KeyError, bst.search, 5)
def test_insert(self): """Inserts left children; inserts right children; replaces values; inserts at various levels. """ bst = BinarySearchTree(1, "value") inserted_node_right = bst.insert(2, "higher value") inserted_node_left = bst.insert(0, "lower value") assert bst.root.right is inserted_node_right assert bst.root.left is inserted_node_left bst.insert(2, "some different value") assert bst.root.right.value == "some different value" rightmost_node = bst.insert(3, "an even higher value") assert bst.root.right.right is rightmost_node
def setUp(self): self.empty_bst = BinarySearchTree() self.one_node_bst = BinarySearchTree() self.one_node_bst.insert(1) # ______8 # / \ # 3__ 10___ # / \ \ # 1 6 _14 # / \ / # 4 7 13 self.insert_items = [8, 3, 10, 1, 6, 14, 4, 7, 13] self.bst = BinarySearchTree() for i in self.insert_items: self.bst.insert(i) array = binarytree.bst(is_perfect=True).values self.perfect_bst = BinarySearchTree.from_array_representation(array)
def test_instantiate_single_root(): bst = BinarySearchTree() bst.add(1) assert bst.root.value == 1
class BinarySearchTreeTest(unittest.TestCase): def setUp(self): self.empty_bst = BinarySearchTree() self.one_node_bst = BinarySearchTree() self.one_node_bst.insert(1) # ______8 # / \ # 3__ 10___ # / \ \ # 1 6 _14 # / \ / # 4 7 13 self.insert_items = [8, 3, 10, 1, 6, 14, 4, 7, 13] self.bst = BinarySearchTree() for i in self.insert_items: self.bst.insert(i) array = binarytree.bst(is_perfect=True).values self.perfect_bst = BinarySearchTree.from_array_representation(array) def test__eq__(self): tree_1 = BinarySearchTree() for i in self.insert_items: tree_1.insert(i) self.assertEqual(self.bst, tree_1) tree_2 = BinarySearchTree() for i in [1, 2, 3]: tree_2.insert(i) self.assertNotEqual(self.bst, tree_2) self.assertNotEqual(self.bst, self.empty_bst) def test__len__(self): self.assertEqual(len(self.empty_bst), 0) self.assertEqual(len(self.bst), len(self.insert_items)) def test__iter__(self): items = list(self.bst) expected = [8, 3, 10, 1, 6, 14, 4, 7, 13] self.assertEqual(items, expected) def test__contains__(self): self.assertIn(random.choice(self.insert_items), self.bst) self.assertNotIn(100, self.bst) def test_is_valid(self): self.assertEqual(self.empty_bst.is_valid(), True) self.assertEqual(self.one_node_bst.is_valid(), True) self.assertEqual(self.bst.is_valid(), True) def test_is_full(self): self.assertEqual(self.empty_bst.is_full(), True) self.assertEqual(self.one_node_bst.is_full(), True) self.assertEqual(self.bst.is_full(), False) self.assertEqual(self.perfect_bst.is_full(), True) def test_is_complate(self): self.assertEqual(self.empty_bst.is_complate(), True) self.assertEqual(self.one_node_bst.is_complate(), True) self.assertEqual(self.bst.is_complate(), False) self.assertEqual(self.perfect_bst.is_complate(), True) def test_is_balanced(self): self.assertEqual(self.empty_bst.is_balanced(), True) self.assertEqual(self.one_node_bst.is_balanced(), True) self.assertEqual(self.bst.is_balanced(), False) self.assertEqual(self.perfect_bst.is_balanced(), True) def test_is_perfect(self): self.assertEqual(self.empty_bst.is_perfect(), True) self.assertEqual(self.one_node_bst.is_perfect(), True) self.assertEqual(self.bst.is_perfect(), False) self.assertEqual(self.perfect_bst.is_perfect(), True) def test_is_root(self): self.assertEqual(self.bst.is_root(self.bst.root), True) self.assertEqual(self.bst.is_root(self.bst.root.left), False) self.assertEqual(self.bst.is_root(self.bst.root.right), False) def test_children(self): self.assertEqual(list(self.bst.children(self.bst.root)), [self.bst.root.left, self.bst.root.right]) self.assertEqual(list(self.bst.children(self.bst.root.left)), [self.bst.root.left.left, self.bst.root.left.right]) self.assertEqual(list(self.bst.children(self.bst.root.right)), [ self.bst.root.right.right, ]) self.assertEqual(list(self.bst.children(self.bst.root.left.left)), []) def test_num_children(self): self.assertEqual(self.bst.num_children(self.bst.root), 2) self.assertEqual(self.bst.num_children(self.bst.root.left), 2) self.assertEqual(self.bst.num_children(self.bst.root.right), 1) self.assertEqual(self.bst.num_children(self.bst.root.left.left), 0) def test_is_leaf(self): self.assertEqual(self.bst.is_leaf(self.bst.root.left.left), True) self.assertEqual(self.bst.is_leaf(self.bst.root.left.right.left), True) self.assertEqual(self.bst.is_leaf(self.bst.root.left.right.right), True) self.assertEqual(self.bst.is_leaf(self.bst.root.right.right.left), True) self.assertEqual(self.bst.is_leaf(self.bst.root), False) self.assertEqual(self.bst.is_leaf(self.bst.root.left), False) self.assertEqual(self.bst.is_leaf(self.bst.root.right), False) def test_height(self): self.assertEqual(self.empty_bst.height(), -1) self.assertEqual(self.one_node_bst.height(), 0) self.assertEqual(self.bst.height(), 3) self.assertEqual(self.bst.height(self.bst.root.left.left), 0) self.assertEqual(self.bst.height(self.bst.root.left.right), 1) self.assertEqual(self.bst.height(self.bst.root.right), 2) self.bst.insert(15) self.bst.insert(30) self.assertEqual(self.bst.height(), 4) def test_depth(self): self.assertEqual(self.bst.depth(self.bst.root), 0) self.assertEqual(self.bst.depth(self.bst.root.right), 1) self.assertEqual(self.bst.depth(self.bst.root.right.right), 2) self.assertEqual(self.bst.depth(self.bst.root.left.right.left), 3) self.bst.insert(15) self.bst.insert(30) self.assertEqual(self.bst.depth(self.bst.root.right.right.right.right), 4) def test_level(self): self.assertEqual(self.bst.level(self.bst.root), 1) self.assertEqual(self.bst.level(self.bst.root.right), 2) self.assertEqual(self.bst.level(self.bst.root.right.right), 3) self.assertEqual(self.bst.level(self.bst.root.left.right.left), 4) self.bst.insert(15) self.bst.insert(30) self.assertEqual(self.bst.level(self.bst.root.right.right.right.right), 5) def test_num_edges(self): self.assertEqual(self.empty_bst.num_edges(), 0) self.assertEqual(self.bst.num_edges(), len(self.bst) - 1) def test_search(self): self.assertEqual(self.bst.search(8), self.bst.root) self.assertEqual(self.bst.search(1), self.bst.root.left.left) self.assertEqual(self.bst.search(13), self.bst.root.right.right.left) self.assertEqual(self.bst.search(100), None) def test_get_min_node(self): self.assertEqual(self.bst.get_min_node().value, min(self.insert_items)) def test_get_max_node(self): self.assertEqual(self.bst.get_max_node().value, max(self.insert_items)) def test_delete(self): with self.assertRaises(ValueError): self.bst.delete(100) bst2 = pythonds3.BinarySearchTree() for i in self.insert_items: bst2.put(key=i, value=i) # ______8 # / \ # 3__ 10___ # \ \ # 6 _14 # / \ / # 4 7 13 self.bst.delete(1) bst2.delete(1) self.assertEqual(len(self.bst), len(bst2)) self.assertEqual(list(self.bst.traverse()), list(bst2)) self.assertEqual(self.bst.is_valid(), True) # ______10___ # / \ # 3__ _14 # \ / # 6 13 # / \ # 4 7 self.bst.delete(8) bst2.delete(8) self.assertEqual(len(self.bst), len(bst2)) self.assertEqual(list(self.bst.traverse()), list(bst2)) self.assertEqual(self.bst.is_valid(), True) # ____10___ # / \ # 3__ _14 # \ / # 7 13 # / # 4 self.bst.delete(6) bst2.delete(6) self.assertEqual(len(self.bst), len(bst2)) self.assertEqual(list(self.bst.traverse()), list(bst2)) self.assertEqual(self.bst.is_valid(), True) self.bst.delete(10) self.bst.delete(4) self.bst.delete(7) self.bst.delete(14) self.bst.delete(3) self.bst.delete(13) self.assertEqual(len(self.bst), 0) self.assertFalse(self.bst) self.assertEqual(self.bst.is_valid(), True) def test_inorder_traverse(self): items = list(self.bst.inorder_traverse()) expected = [1, 3, 4, 6, 7, 8, 10, 13, 14] self.assertEqual(items, expected) items = list(self.bst.inorder_traverse(self.bst.root.right.left)) expected = [] self.assertEqual(items, expected) def test_preorder_traverse(self): items = list(self.bst.preorder_traverse()) expected = [8, 3, 1, 6, 4, 7, 10, 14, 13] self.assertEqual(items, expected) def test_postorder_traverse(self): items = list(self.bst.postorder_traverse()) expected = [1, 4, 7, 6, 3, 13, 14, 10, 8] self.assertEqual(items, expected) def test_levelorder_traverse(self): items = list(self.bst.levelorder_traverse()) expected = [8, 3, 10, 1, 6, 14, 4, 7, 13] self.assertEqual(items, expected) def test_traverse(self): with self.assertRaises(ValueError): self.bst.traverse('NOT EXIST') def test_invert(self): self.empty_bst.invert() self.bst.invert() items = list(self.bst.levelorder_traverse()) expected = [8, 10, 3, 14, 6, 1, 13, 7, 4] self.assertEqual(items, expected) self.assertEqual(self.bst.is_valid(), False) def test_to_array_representation(self): array = self.empty_bst.to_array_representation() self.assertEqual(array, []) array = self.bst.to_array_representation() root = binarytree.build(array) self.assertEqual(array, root.values) def test_from_array_representation(self): array = binarytree.bst(height=random.randint(0, 9), is_perfect=random.choice([True, False])).values bst = BinarySearchTree.from_array_representation(array) self.assertEqual(array, bst.to_array_representation())
def test_binary_search_tree(self): # initialize test variables BST = BinarySearchTree() seq = range(1000) # randomly insert values into BST random.shuffle(seq) for val in seq: BST.insert(val) self.assertEqual(BST.find(val), val) # test that values are present in BST for val in seq: self.assertEqual(BST.find(val), val) # test inorder traversal of BST seq.sort() self.assertEqual(BST.traverse(), seq) # randomly remove values from BST random.shuffle(seq) for val in seq: self.assertEqual(BST.find(val), val) BST.delete(val) self.assertEqual(BST.find(val), None) # test that values are not present in BST for val in seq: self.assertEqual(BST.find(val), None)
class TestTreeTraversals(unittest.TestCase): def setUp(self): self.root = self.create_test_root() self.tree = BinarySearchTree(self.root) def test_get_max(self): assert_that(7).is_equal_to(self.tree.get_max().value) def test_get_min(self): assert_that(1).is_equal_to(self.tree.get_min().value) def test_binary_search(self): find = self.tree.find(3) assert_that(find).is_not_none() def test_insert(self): self.tree.insert(8) inorder_order = [1, 2, 3, 4, 5, 6, 7, 8] for i, node in enumerate(inorder(self.root)): assert_that(inorder_order[i]).is_equal_to(node.value) def test_find_parent(self): parent = self.tree.find_parent(1) assert_that(2).is_equal_to(parent.value) def test_remove(self): self.tree.remove(6) inorder_order = [1, 2, 3, 4, 5, 7, 8] for i, node in enumerate(inorder(self.root)): assert_that(inorder_order[i]).is_equal_to(node.value) def test_to_max_heap(self): max_heap = [7, 6, 5, 4, 3, 2, 1] for i, node in enumerate(self.tree.to_max_heap(self.root)): assert_that(max_heap[i]).is_equal_to(node.value) def test_find_lowest_common_ancestor(self): node_a, node_b = Node(2), Node(5) expected_lca = Node(4) result_lca = self.tree.find_lowest_common_ancestor(node_a, node_b) assert_that(result_lca).is_equal_to(expected_lca) def test_reconstruct_tree(self): serialized_tree = self.tree.serialize() inorder_lst, preorder_lst = serialized_tree['inorder'], serialized_tree['preorder'] reconstructed_tree = BinarySearchTree.deserialize(inorder_lst, preorder_lst) inorder_order = [1, 2, 3, 4, 5, 6, 7] for i, node in enumerate(inorder(reconstructed_tree.root)): assert_that(inorder_order[i]).is_equal_to(node.value) def create_test_root(self): root = Node(4) root.left, root.right = Node(2), Node(6) root.left.left, root.left.right = Node(1), Node(3) root.right.left, root.right.right = Node(5), Node(7) return root
def setUp(self): self.root = self.create_test_root() self.tree = BinarySearchTree(self.root)
def test_delete(self): bst = BinarySearchTree(1) assert_raises(RootDeletionError, bst.delete, 1) inserted_node = bst.insert(2) assert bst.root.right is inserted_node bst.delete(2, drop_subtree=True) assert isinstance(bst.root.right, NullNode) bst.insert(8) new_predecessor = bst.insert(9) bst.insert(7) bst.insert(6) bst.insert(10) bst.delete(8) assert bst.root.right is new_predecessor assert bst.root.right.left.key == 7 assert bst.root.right.left.predecessor is new_predecessor assert bst.root.right.right.key == 10 assert_raises(KeyError, bst.search, 8) bst = BinarySearchTree(1) bst.insert(8) bst.insert(7) bst.insert(6) bst.insert(9) bst.insert(10) new_predecessor = bst.insert(8.5) bst.insert(8.75) bst.delete(8) assert bst.root.right is new_predecessor assert bst.root.right.right.key == 9 assert bst.root.right.right.predecessor is new_predecessor assert bst.root.right.left.key == 7 assert bst.root.right.right.left.key == 8.75 assert_raises(KeyError, bst.search, 8)
def test_add_to_right(): bst = BinarySearchTree() bst.add(3) bst.add(2) bst.add(6) assert bst.root.right.value == 6