def test_add_multiple_items_in_balanced_way_should_be_sorted(self):
nums = [20, 10, 30, 0, 15, 25, 40]
avl_tree = AvlTree()
for num in nums:
avl_tree.add(num)
expected_items = list(sorted(nums))
self.assertEqual(list(avl_tree), expected_items)
self.assertEqual(len(avl_tree), len(expected_items))
def test_add_multiple_items_random_order_should_be_sorted_2(self):
avl_tree = AvlTree()
nums = [
20, 21, 22, 21, 24, 16, 5, 29, 23, 9, 2, 7, 3, 23, 8, 7, 10, 10,
18, 26, 4, 17, 12, 11, 21, 23, 24, 19, 9, 0
]
expected_nums = list(sorted(set(nums)))
for num in nums:
avl_tree.add(num)
self.assertEqual(list(avl_tree), expected_nums)
def test_add_many_random_elements_should_return_sorted_ascending(self):
num_count = 1000
avl_tree = AvlTree()
expected_items = set()
for _ in range(num_count):
rand_num = random.randint(0, num_count)
avl_tree.add(rand_num)
expected_items.add(rand_num)
expected_items = list(sorted(expected_items))
self.assertEqual(list(avl_tree), expected_items)
self.assertEqual(len(avl_tree), len(expected_items))
def setUp(self):
self.avl = AvlTree()
self.avl[70] = '1st'
self.avl[31] = '2nd'
self.avl[93] = '3rd'
self.avl[99] = '4th'
self.avl.put(14, '5th')
self.avl.put(23, '6th')
self.avl.put(73, '7th')
self.avl.put(71, '8th')
self.avl.put(82, '9th')
self.avl.put(95, '10th')
self.avl.put(80, '11th')
def test_delete_multiple_avl(self, _, input_data, delete_data,
expected_result):
avl = AvlTree.build_from_list(input_data)
for key in delete_data:
avl.delete_by_key(key)
res = avl.iterative_inorder()
assert expected_result == res
def get_type(self, tree):
dummyType = AvlTree("dummy")
logger.debug("Type of tree: {}, {}".format(type(tree),
type(dummyType)))
if type(tree) == type(dummyType):
del dummyType
return "(AVL Tree)"
del dummyType
return "(Binary Heap)"
def CreateTreeNamed(self, name, type="avltree"):
try:
self.trees[name]
logger.error("There is already a tree with name: {0}".format(name))
except KeyError:
logger.info("Created new Tree of type {} linked".format(type))
if "heap" == type:
self.trees[name] = BinaryMinHeap(name)
else:
self.trees[name] = AvlTree(name)
return
raise ValueError
def plot(measure_tree, measure_heap, title, xlabel, ylabel):
(x, y) = get_x_y(measure_tree)
(u, v) = get_x_y(measure_heap)
axes = plt.gca()
axes.set_ylim([0, max(y[:] + v[:])])
plt.scatter(x, y, c='red', label="AVL Tree")
plt.scatter(u, v, c='blue', label="Binary Heap")
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.legend(loc='best')
plt.show()
avl = AvlTree("Tree")
heap = BinaryMinHeap("Heap")
measure_insert_tree = []
measure_insert_heap = []
measure_find_tree = []
measure_find_heap = []
measure_deletemin_tree = []
measure_deletemin_heap = []
num_trials = 10000
# Insert Tree
for i in range(1, num_trials):
t1 = time.perf_counter()
avl.insert(randint(1000000000, 9999999999))
t2 = time.perf_counter()
class TestAvlTree(unittest.TestCase):
def setUp(self):
self.avl = AvlTree()
self.avl[70] = '1st'
self.avl[31] = '2nd'
self.avl[93] = '3rd'
self.avl[99] = '4th'
self.avl.put(14, '5th')
self.avl.put(23, '6th')
self.avl.put(73, '7th')
self.avl.put(71, '8th')
self.avl.put(82, '9th')
self.avl.put(95, '10th')
self.avl.put(80, '11th')
def test_getContains(self):
keys = [14, 23, 31, 70, 71, 73, 80, 82, 93, 95, 99]
bfs = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]
it = iter(self.avl)
i = 0
for e in it:
self.assertEqual(keys[i], e.key)
self.assertEqual(bfs[i], e.balanceFactor)
i += 1
self.assertIsNone(self.avl[40])
self.assertEqual('1st', self.avl[70])
self.assertEqual('2nd', self.avl[31])
self.assertEqual('3rd', self.avl[93])
self.assertEqual('4th', self.avl[99])
self.assertEqual('5th', self.avl.get(14))
self.assertEqual('6th', self.avl.get(23))
self.assertEqual('7th', self.avl.get(73))
self.assertEqual('8th', self.avl.get(71))
self.assertEqual('9th', self.avl.get(82))
self.assertEqual('10th', self.avl.get(95))
self.assertEqual('11th', self.avl.get(80))
self.assertTrue(23 in self.avl)
self.assertFalse(111 in self.avl)
def test_del(self):
size = self.avl.size
result = [
'[14,0], [23,0], [31,0], [70,1], [71,0], [80,0], [82,0], [93,-1], [95,0], [99,1], ',
'[14,0], [23,0], [31,0], [70,1], [71,0], [82,1], [93,0], [95,0], [99,0], ',
'[14,0], [23,0], [31,0], [70,1], [71,0], [93,1], [95,-1], [99,0], ',
'[14,0], [23,0], [31,0], [70,0], [71,0], [95,0], [99,0], ',
'[14,0], [23,0], [31,0], [71,0], [95,-1], [99,0], ',
'[14,0], [23,0], [31,0], [95,1], [99,0], ',
'[14,0], [23,-1], [31,0], [99,1], ', '[14,0], [31,0], [99,0], ',
'[14,0], [99,1], ', '[14,0], ', ''
]
for i in range(size):
del self.avl[self.avl.root.key]
self.assertEqual(result[i], str(self.avl))
def test_add_several_elements_should_increase_count(self):
avl_tree = AvlTree()
nums = [1, 2, 3]
for num in nums:
avl_tree.add(num)
self.assertEqual(len(avl_tree), len(nums))
def test_add_repeating_elements_should_not_add_duplicates(self):
avl_tree = AvlTree()
nums = [3, 3, 3, 3]
for num in nums:
avl_tree.add(num)
self.assertEqual(len(avl_tree), len(set(nums)))
from avl_node import AvlNode
from avl_tree import AvlTree
if __name__ == "__main__":
keys = AvlTree()
keys.insert(AvlNode("name", "john"))
keys.insert(AvlNode("lastname", "doe"))
keys.insert(AvlNode("email", "*****@*****.**"))
keys.insert(AvlNode("address", "john doe 22"))
keys.insert(AvlNode("phone", "12345"))
keys.insert(AvlNode("nick", "johndoe"))
keys.insert(AvlNode("country", "croatia"))
keys.insert(AvlNode("favorites", ["icecream", "chocolate", "coffee", "wine"]))
keys.print_tree()
print str(keys.find(AvlNode("country", "")).value)
keys.remove(AvlNode("country", ""))
print str(keys.find(AvlNode("country", "")))
print str(keys.find(AvlNode("favorites", "")).value)
def test_delete_in_avl(self, _, input_data, key):
avl = AvlTree.build_from_list(input_data)
avl.delete_by_key(key)
res = set(avl.iterative_inorder())
assert key not in res
def test_build_avl(self, _, input_data, expected):
avl = AvlTree.build_from_list(input_data)
inorder = avl.iterative_inorder()
assert inorder == expected