def test_BinomialTree():
assert raises(TypeError, lambda: BinomialTree(1, 1))
assert raises(TypeError, lambda: BinomialTree(None, 1.5))
bt = BinomialTree()
assert raises(TypeError, lambda: bt.add_sub_tree(None))
bt1 = BinomialTree(BinomialTreeNode(1, 1), 0)
node = BinomialTreeNode(2, 2)
node.add_children(BinomialTreeNode(3, 3))
bt2 = BinomialTree(node, 1)
assert raises(ValueError, lambda: bt1.add_sub_tree(bt2))
assert bt1.is_empty is False
def delete_minimum(self):
"""
Deletes the node with minimum key.
"""
min_node, min_idx = self.find_minimum(get_index=True)
child_root_list = []
for k, child in enumerate(min_node.children):
if child is not None:
child_root_list.append(BinomialTree(root=child, order=k))
self.root_list.remove(self.root_list[min_idx])
child_heap = BinomialHeap(root_list=child_root_list)
self.merge(child_heap)
def insert(self, key, data=None):
"""
Inserts new node with the given key and data.
key
The key of the node which can be operated
upon by relational operators.
data
The data to be stored in the new node.
"""
new_node = BinomialTreeNode(key, data)
new_tree = BinomialTree(root=new_node, order=0)
new_heap = BinomialHeap(root_list=[new_tree])
self.merge(new_heap)
def test_BinomialHeap():
# Corner cases
assert raises(
TypeError,
lambda: BinomialHeap(root_list=[BinomialTreeNode(1, 1), None])) is True
tree1 = BinomialTree(BinomialTreeNode(1, 1), 0)
tree2 = BinomialTree(BinomialTreeNode(2, 2), 0)
bh = BinomialHeap(root_list=[tree1, tree2])
assert raises(TypeError,
lambda: bh.merge_tree(BinomialTreeNode(2, 2), None))
assert raises(TypeError, lambda: bh.merge(None))
# Testing BinomialHeap.merge
nodes = [
BinomialTreeNode(1, 1), # 0
BinomialTreeNode(3, 3), # 1
BinomialTreeNode(9, 9), # 2
BinomialTreeNode(11, 11), # 3
BinomialTreeNode(6, 6), # 4
BinomialTreeNode(14, 14), # 5
BinomialTreeNode(2, 2), # 6
BinomialTreeNode(7, 7), # 7
BinomialTreeNode(4, 4), # 8
BinomialTreeNode(8, 8), # 9
BinomialTreeNode(12, 12), # 10
BinomialTreeNode(10, 10), # 11
BinomialTreeNode(5, 5), # 12
BinomialTreeNode(21, 21)
] # 13
nodes[2].add_children(nodes[3])
nodes[4].add_children(nodes[5])
nodes[6].add_children(nodes[9], nodes[8], nodes[7])
nodes[7].add_children(nodes[11], nodes[10])
nodes[8].add_children(nodes[12])
nodes[10].add_children(nodes[13])
tree11 = BinomialTree(nodes[0], 0)
tree12 = BinomialTree(nodes[2], 1)
tree13 = BinomialTree(nodes[6], 3)
tree21 = BinomialTree(nodes[1], 0)
heap1 = BinomialHeap(root_list=[tree11, tree12, tree13])
heap2 = BinomialHeap(root_list=[tree21])
def bfs(heap):
bfs_trav = []
for i in range(len(heap.root_list)):
layer = []
bfs_q = Queue()
bfs_q.append(heap.root_list[i].root)
while len(bfs_q) != 0:
curr_node = bfs_q.popleft()
if curr_node is not None:
layer.append(curr_node.key)
for _i in range(curr_node.children._last_pos_filled + 1):
bfs_q.append(curr_node.children[_i])
if layer != []:
bfs_trav.append(layer)
return bfs_trav
heap1.merge(heap2)
expected_bfs_trav = [[1, 3, 9, 11], [2, 8, 4, 7, 5, 10, 12, 21]]
assert bfs(heap1) == expected_bfs_trav
# Testing Binomial.find_minimum
assert heap1.find_minimum().key == 1
# Testing Binomial.delete_minimum
heap1.delete_minimum()
assert bfs(heap1) == [[3], [9, 11], [2, 8, 4, 7, 5, 10, 12, 21]]
assert raises(ValueError, lambda: heap1.decrease_key(nodes[3], 15))
heap1.decrease_key(nodes[3], 0)
assert bfs(heap1) == [[3], [0, 9], [2, 8, 4, 7, 5, 10, 12, 21]]
heap1.delete(nodes[12])
assert bfs(heap1) == [[3, 8], [0, 9, 2, 7, 4, 10, 12, 21]]
# Testing BinomialHeap.insert
heap = BinomialHeap()
assert raises(IndexError, lambda: heap.find_minimum())
heap.insert(1, 1)
heap.insert(3, 3)
heap.insert(6, 6)
heap.insert(9, 9)
heap.insert(14, 14)
heap.insert(11, 11)
heap.insert(2, 2)
heap.insert(7, 7)
assert bfs(heap) == [[1, 3, 6, 2, 9, 7, 11, 14]]
