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