def test_pop_right_min_returns_min(self):
a = AVLTree()
a[5] = 'a'
a[1] = 'a'
a[9] = 'a'
a[8] = 'a'
self.assertEqual(a._pop_right_min(a.root).key, 8)
def test_len_on_clear(self):
a = AVLTree()
a[1] = 'a'
a[2] = 'a'
a[3] = 'a'
a.clear()
self.assertEqual(len(a), 0)
def test_get_min_is_left_of_root2(self):
a = AVLTree()
a[5] = 'a'
a[1] = 'a'
a[4] = 'a'
a[3] = 'a'
a[2] = 'a'
self.assertEqual(a._get_min(a.root).key, 1)
def test_get_min(self):
import random
a = AVLTree()
m = None
for _ in range(100):
r = random.randint(-9999, 9999)
m = min(r, m or r)
a[r] = 'a'
self.assertEqual(a._get_min(a.root).key, m)
def test_pop_right_min_removes_min(self):
a = AVLTree()
a[5] = 'a'
a[1] = 'a'
a[9] = 'a'
a[8] = 'a'
self.assertIsNotNone(a.root.right.left)
a._pop_right_min(a.root)
self.assertIsNone(a.root.right.left)
def test_pop_right_min_removes_min_and_keeps_children(self):
a = AVLTree()
a[5] = 'a'
a[1] = 'a'
a[8] = 'a'
a[9] = 'a'
self.assertEqual(a.root.right.key, 8)
a._pop_right_min(a.root)
self.assertEqual(a.root.right.key, 9)
def test_item_iterator(self):
a = AVLTree()
values = [
(1, 'a'),
(2, 'b'),
(3, 'c'),
]
for k, v in values:
a[k] = v
self.assert_list(a.items(), values)
def test_value_iterator(self):
a = AVLTree()
values = [
(1, 'a'),
(2, 'b'),
(3, 'c'),
]
for k, v in values:
a[k] = v
self.assert_list(a.values(), [v for _, v in values])
def test_key_iterator(self):
a = AVLTree()
values = [
(1, 'a'),
(2, 'b'),
(3, 'c'),
]
for k, v in values:
a[k] = v
self.assert_list(a.keys(), [k for k, _ in values])
def test_clear_is_empty(self):
a = AVLTree()
a[1] = 'a'
a[2] = 'a'
a[3] = 'a'
a.clear()
with self.assertRaises(KeyError):
_ = a[1]
with self.assertRaises(KeyError):
_ = a[2]
with self.assertRaises(KeyError):
_ = a[3]
def test_copy_doesn_not_reuse_nodes(self):
a = AVLTree(a=1, b=2, c=3, d=4, e=5, f=6)
b = a.copy()
travel_a = InOrderTraversal(a.root, lambda x: x)
travel_b = InOrderTraversal(b.root, lambda x: x)
while True:
_a = next(travel_a, None)
_b = next(travel_b, None)
if _a is None and _b is None:
break
self.assertIsNot(_a, _b)
def test_not_contains(self):
a = AVLTree()
a[1] = 'a'
a[2] = 'a'
a[3] = 'a'
self.assertFalse(0 in a)
self.assertFalse(4 in a)
def test_iterable_create_by_kwargs(self):
a = AVLTree(
a='a',
b='b',
c='c',
)
self.assertEqual(len(a), 3)
def test_delete_empty_node_updates_len(self):
a = AVLTree()
a[5] = 'a'
a[3] = 'a'
a[7] = 'a'
del a[7]
self.assertEqual(2, len(a))
def test_contains(self):
a = AVLTree()
a[1] = 'a'
a[2] = 'a'
a[3] = 'a'
self.assertTrue(1 in a)
self.assertTrue(2 in a)
self.assertTrue(3 in a)
def test_delete_node_with_right_updates_len(self):
a = AVLTree()
a[5] = 'a'
a[3] = 'a'
a[7] = 'a'
a[9] = 'a'
del a[7]
self.assertEqual(3, len(a))
def test_delete_node_with_both_case(self):
a = AVLTree()
a[5] = 'a'
a[4] = 'a'
a[6] = 'a'
expected = a.root.right
del a[5]
self.assertEqual(a.root, expected)
def test_delete_node_with_left_case(self):
a = AVLTree()
a[5] = 'a'
a[1] = 'b'
expected = a.root.left
del a[5]
self.assertEqual(a.root, expected)
def test_update_in_place(self):
a = AVLTree()
a[1] = 'a'
a[2] = 'b'
a[3] = 'a'
self.assertEqual(a[2], "b")
a[2] = 'c'
self.assertEqual(a[2], "c")
self.assertEqual(len(a), 3)
def test_depth_7_nodes(self):
a = AVLTree()
a[1] = "a"
a[2] = "a"
a[3] = "a"
a[4] = "a"
a[5] = "a"
a[6] = "a"
a[7] = "a"
self.assertEqual(a.root.height, 2)
def test_longer_item(self):
a = AVLTree([
# Order of insert is important because
# repr should do a breadth first traversal.
("a", 1), ("b", 2),
("c", 3), ("d", 4),
("e", 5), ("f", 6),
("g", 7), ("g", 7),
])
self.assertEqual(str(a), "<AVL {d: 4, b: 2, f: 6, a: 1, c: 3, e: 5, g: 7}>")
def test_delete_keeps_avl_property(self):
a = AVLTree()
a[5] = 'a'
a[3] = 'a'
a[7] = 'a'
a[1] = 'a'
a[4] = 'a'
a[8] = 'a'
a[2] = 'a'
# Because this is complex (to me), i am asserting the expected
# structure just to make sure i didn't messup the setup.
# 5
# / \
# 3 7
# / \ \
# 1 4 8
# \
# 2
r = a.root
self.assertEqual(r.key, 5)
self.assertEqual(r.left.key, 3)
self.assertEqual(r.left.left.key, 1)
self.assertEqual(r.left.left.right.key, 2)
self.assertEqual(r.left.right.key, 4)
self.assertEqual(r.right.key, 7)
self.assertEqual(r.right.right.key, 8)
# Delete key 7 should cause a rebalance that looks like this
# 3
# / \
# / \
# 1 5
# \ / \
# 2 4 8
del a[7]
r = a.root
self.assertEqual(r.key, 3)
self.assertEqual(r.left.key, 1)
self.assertEqual(r.left.right.key, 2)
self.assertEqual(r.right.key, 5)
self.assertEqual(r.right.left.key, 4)
self.assertEqual(r.right.right.key, 8)
def test_creats_new_tree(self):
a = AVLTree.fromkeys([], None)
self.assertIsInstance(a, AVLTree)
def test_from_array(self):
a = AVLTree.fromkeys([1, 2, 3], None)
self.assertListEqual(list(a.items()), [(1, None), (2, None), (3, None)])
def test_copy_empty(self):
a = AVLTree()
b = a.copy()
self.assertIsNot(a, b)
def test_copy_contains_same_items(self):
a = AVLTree(a=1, b=2, c=3, d=4, e=5, f=6)
b = a.copy()
self.assertListEqual(list(a), list(b))
def test_copy_contains_same_count(self):
a = AVLTree(a=1, b=2, c=3)
b = a.copy()
self.assertEqual(len(b), 3)
def test_iterable_create(self):
a = AVLTree([(1, 'a'), (2, 'b'), (3, 'c')])
self.assertEqual(len(a), 3)
def test_empty_create(self):
a = AVLTree()
self.assertEqual(len(a), 0)
def test_iterable_create_by_both(self):
a = AVLTree([('a', 'a'), ('b', 'b')], c='c')
self.assertEqual(len(a), 3)
