def test_node_balance_factor(self): data = [1, 2] avl_tree = AVLTree(data) assert avl_tree.root.balance_factor() == -1 data = [2, 1] avl_tree = AVLTree(data) assert avl_tree.root.balance_factor() == 1
def test_balanced_tree_must_have_height_of_log2(self):
import math
base = 2
for exp in range(2, 13):
tree1 = AVLTree()
tree2 = AVLTree()
tree3 = AVLTree()
entries = [i for i in range(base**exp)]
for entry in entries:
tree1.insert(entry)
if entry == 0:
continue
tree2.insert(entry)
if entry == 1:
continue
tree3.insert(entry)
with self.subTest(f"test inserting {len(entries)} elements."):
self.assertEqual(tree1.height,
int(math.log2(len(entries))) + 1)
self.assertEqual(len(tree1), len(entries))
with self.subTest(f"test inserting {len(entries)-1} elements."):
self.assertEqual(tree2.height, int(math.log2(len(entries))))
self.assertEqual(len(tree2), len(entries) - 1)
with self.subTest(f"test inserting {len(entries)-2} elements."):
self.assertEqual(tree3.height, int(math.log2(len(entries))))
self.assertEqual(len(tree3), len(entries) - 2)
def test_length(self):
tree = AVLTree()
entries = range(150)
for entry in entries:
tree.insert(entry)
with self.subTest("test non-empty tree"):
self.assertEqual(len(tree), len(entries))
with self.subTest("test empty tree"):
self.assertEqual(len(AVLTree()), 0)
def test_single_right_rotation_1(self): data = [3, 2, 1] avl_tree = AVLTree(data) assert avl_tree.root.data == 2 assert avl_tree.root.left_child.data == 1 assert avl_tree.root.right_child.data == 3 assert avl_tree.items_level_order() == [2, 1, 3]
def test_insertPreOrderWithRootAndLeftRightNodes(self):
tree = AVLTree()
tree.insert(4)
tree.insert(3)
tree.insert(5)
nodes = tree.preorder_traversal()
self.assertEqual(nodes, [4, 3, 5])
def test_insertPreOrderCheckTypeErrorRaised(self):
tree = AVLTree()
tree.insert('a')
try:
tree.insert(4)
except TypeError:
return True
def test_insert_remove(
size
): # test tree from random, delete, and rebalance, setitem with existing key
lbase = list(range(0, size))
random.shuffle(lbase) # randomize
dref = {}
tree = AVLTree()
for key in lbase:
v = random.choice(lbase)
tree[key] = v
dref[key] = v
assert_true(
dict_to_sorted_pairs(dref) == list(tree),
f"random tree did not match reference")
assert_true(
is_balanced(tree),
f"1 tree is not balanced after inserting {size} random keys/values"
)
assert_true(
dict_to_sorted_pairs(dref) == list(tree),
f"random tree did not match reference")
deleted_keys = random.sample(lbase, size // 2)
for key in deleted_keys: # delete half of original
del tree[key]
del dref[key]
assert_true(is_balanced(tree),
f"tree is not balanced after deleting key:{key} ")
assert_true(
dict_to_sorted_pairs(dref) == list(tree),
f"random tree did not match reference")
def test_height(self):
tree = AVLTree()
tree.insert(9)
root = tree.root
self.assertEqual(root.height, 1)
tree.insert(4)
self.assertEqual(root.height, 2)
self.assertEqual(root.left.height, 1)
tree.insert(14)
self.assertEqual(root.height, 2)
self.assertEqual(root.left.height, 1)
self.assertEqual(root.right.height, 1)
tree.insert(17)
self.assertEqual(root.height, 3)
self.assertEqual(root.left.height, 1)
self.assertEqual(root.right.height, 2)
self.assertEqual(root.right.right.height, 1)
tree.insert(7)
self.assertEqual(root.height, 3)
self.assertEqual(root.left.height, 2)
self.assertEqual(root.left.right.height, 1)
def test_heightRootNodeLeftRightChildren(self):
tree = AVLTree()
tree.insert(4)
tree.insert(3)
tree.insert(5)
height = tree.get_height(tree.root)
self.assertEqual(height, 2)
def test_balance_factor(self):
tree = AVLTree()
tree.insert(9)
root = tree.root
self.assertEqual(root.balance_factor, 0)
tree.insert(4)
self.assertEqual(root.balance_factor, 1)
self.assertEqual(root.left.balance_factor, 0)
tree.insert(14)
self.assertEqual(root.balance_factor, 0)
self.assertEqual(root.left.balance_factor, 0)
self.assertEqual(root.right.balance_factor, 0)
tree.insert(17)
self.assertEqual(root.balance_factor, -1)
self.assertEqual(root.left.balance_factor, 0)
self.assertEqual(root.right.balance_factor, -1)
self.assertEqual(root.right.right.balance_factor, 0)
tree.insert(7)
self.assertEqual(root.balance_factor, 0)
self.assertEqual(root.left.balance_factor, -1)
self.assertEqual(root.left.right.balance_factor, 0)
def gen_balanced_tree(range_bounds=DEFAULT_RANGE_BOUNDS,
value_bounds=DEFAULT_VALUE_BOUNDS):
"""
Generate a balanced AVLTree from random data
"""
tree = AVLTree()
return fill_random_tree(tree, range_bounds, value_bounds)
def test_right_left_rotation(self):
tree = AVLTree()
tree.insert(1)
root = tree.root
self.assertEqual(root.balance_factor, 0)
self.assertEqual(root.height, 1)
self.assertEqual(root.entry, 1)
tree.insert(3)
root = tree.root
self.assertEqual(root.balance_factor, -1)
self.assertEqual(root.height, 2)
self.assertEqual(root.entry, 1)
self.assertEqual(root.right.entry, 3)
tree.insert(2)
root = tree.root
self.assertEqual(root.balance_factor, 0)
self.assertEqual(root.left.balance_factor, 0)
self.assertEqual(root.right.balance_factor, 0)
self.assertEqual(root.height, 2)
self.assertEqual(root.entry, 2)
self.assertEqual(root.left.entry, 1)
self.assertEqual(root.right.entry, 3)
def test_smaller_entry_on_the_left_of_root(self):
tree = AVLTree()
tree.insert(9)
tree.insert(4)
self.assertEqual(tree.root.entry, 9)
self.assertEqual(tree.root.left.entry, 4)
def test_greater_entry_on_the_right_of_root(self):
tree = AVLTree()
tree.insert(9)
tree.insert(14)
self.assertEqual(tree.root.entry, 9)
self.assertEqual(tree.root.right.entry, 14)
def test_delete_single_element(self):
tree = AVLTree([1])
tree.delete(1)
self.assertNotIn(1, tree)
self.assertFalse(tree)
self.assertEqual(len(tree), 0)
def compare_tree_expected(self, values: list):
"""
Helper function that sorts the given list and compares the result to
an inorder traversal of the AVL.
"""
expected = sorted(values)
actual = AVLTree(values).traverse()
self.assertEqual(expected, actual)
def test_rightRotationOnRoot(self):
tree = AVLTree()
tree.insert(3)
tree.insert(2)
tree.insert(1)
tree.root = tree.right_rotation(tree.root)
nodes = tree.preorder_traversal()
self.assertEqual(nodes, [2, 1, 3])
def test_equals(self):
tree1 = AVLTree([1, 2, 3, 4, 5])
tree2 = AVLTree([2, 1, 4, 3, 5])
tree3 = AVLTree([1, 2, 3, 4, 5, 6])
with self.subTest(f"test equal trees"):
self.assertEqual(tree1, tree2)
self.assertFalse(tree1 is tree2)
with self.subTest(f"test different trees"):
self.assertNotEqual(tree1, tree3)
self.assertFalse(tree1 is tree3)
self.assertNotEqual(tree2, tree3)
self.assertFalse(tree2 is tree3)
with self.subTest(f"test tree is different from other classes"):
self.assertNotEqual(tree1, int(9))
with self.subTest(f"test tree is different from empty tree"):
self.assertNotEqual(tree1, AVLTree())
def test_avl_insertion():
"""Tests that avl insertion maintains balance"""
bintree = AVLTree()
for i in xrange(100):
bintree.insert(random.randint(0, 1e6))
assert bintree.size() == 100
assert abs(bintree.balance()) < 2
assert bintree.depth() < 9 # 2 ** 7 is 128, it should fit
def test_insert_on_empty_tree(self):
tree = AVLTree()
tree.insert(9)
self.assertEqual(tree.root.entry, 9)
self.assertEqual(tree.root.left.balance_factor, 0)
self.assertEqual(tree.root.right.balance_factor, 0)
self.assertTrue(tree)
def test_balanced_tree1(self):
"""
Test against a balanced binary tree
"""
values = [1, 2, 3]
tree, _ = fill_tree(AVLTree(), values)
actual = tree_is_balanced(tree)
self.assertTrue(actual)
def test_delete_leaf_node(self):
tree = AVLTree([1, 2])
tree.delete(2)
self.assertIn(1, tree)
self.assertNotIn(2, tree)
self.assertTrue(tree)
self.assertEqual(len(tree), 1)
def test_update_height(self):
self.assertEqual(self.tree.height, -1)
self.tree.node = Node(5)
self.tree.update_height()
self.assertEqual(self.tree.height, 0)
self.tree.node.left = AVLTree(Node(3))
self.tree.update_height()
self.assertEqual(self.tree.node.left.height, 0)
self.assertEqual(self.tree.height, 1)
self.tree.node.right = AVLTree(Node(6))
self.tree.update_height()
self.assertEqual(self.tree.height, 1)
self.tree.node.right.node.right = AVLTree(Node(8))
self.tree.update_height()
self.assertEqual(self.tree.height, 2)
def test_insertPreOrderWithRootAndLeftRightNodesWithLevel1Children(self):
tree = AVLTree()
tree.insert(4)
tree.insert(3)
tree.insert(1)
tree.insert(2)
tree.insert(5)
nodes = tree.preorder_traversal()
self.assertEqual(nodes, [4, 3, 1, 2, 5])
def test_insert_without_rotations(self):
numbers = [1, 2, 3]
avlTree = AVLTree(numbers)
assert avlTree.root.number == 1
assert avlTree.root.left.number == 2
assert avlTree.root.left.number == 3
assert avlTree.root.height = 1
assert avlTree.root.left.height = 2
assert avlTree.root.right.height = 2
def test_insert_with_left_right_rotation(self):
number = [10, 1, 5]
avlTree = AVLTree(numbers)
assert avlTree.root.number == 5
assert avlTree.root.left.number == 1
assert avlTree.root.left.number == 10
assert avlTree.root.height = 1
assert avlTree.root.left.height = 2
assert avlTree.root.right.height = 2
def test_insert_duplicated_entry(self):
tree = AVLTree()
tree.insert(9)
tree.insert(10)
tree.insert(9)
self.assertEqual(tree.root.entry, 9)
self.assertEqual(tree.root.right.entry, 10)
self.assertEqual(tree.height, 2)
self.assertTrue(tree)
def test_insert_with_left_left_rotation(self):
number = [14, 20, 16]
avlTree = AVLTree(numbers)
assert avlTree.root.number == 16
assert avlTree.root.left.number == 14
assert avlTree.root.left.number == 20
assert avlTree.root.height = 1
assert avlTree.root.left.height = 2
assert avlTree.root.right.height = 2
def test_delete_entry_make_tree_unbalanced(self):
entries = [5, 3, 8, 2, 4, 7, 11, 1, 6, 10, 12, 9]
tree = AVLTree(entries)
entry_to_be_deleted = 4
tree.delete(entry_to_be_deleted)
expected_order = (8, 5, 11, 2, 7, 10, 12, 1, 3, 6, 9)
self.assertNotIn(entry_to_be_deleted, tree)
self.assertTupleEqual(tuple(tree.traverse('bfs')), expected_order)
def test_delete_entry_but_tree_remains_balanced(self):
entries = [10, 5, 11, 3, 7, 15]
tree = AVLTree(entries)
entry_to_be_deleted = 10
tree.delete(entry_to_be_deleted)
expected_order = (7, 5, 11, 3, 15)
self.assertNotIn(entry_to_be_deleted, tree)
self.assertTupleEqual(tuple(tree.traverse('bfs')), expected_order)
