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