def insert(self, value):
'''
Inserts value into the heap.
'''
if self.root is None:
self.root = Node(value)
self.root.descendents = 1
self.root.parent = None
else:
tree_size = Heap.size(self.root)
tree_size = tree_size + 1
tree_size = bin(tree_size).replace("0b", "")
tree_size = tree_size[1:]
cur_node = self.root
for num in tree_size[:-1]:
if num == '0':
cur_node = cur_node.left
if num == '1':
cur_node = cur_node.right
if tree_size[-1] == '0':
cur_node.left = Node(value)
cur_node.left.parent = cur_node
self.root = Heap._trickle_up(cur_node.left)
else:
cur_node.right = Node(value)
cur_node.right.parent = cur_node
self.root = Heap._trickle_up(cur_node.right)
def _insert(value, node):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
AVLTree._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
AVLTree._insert(value, node.right)
else:
print("already here")
if not AVLTree._is_avl_satisfied(node):
node.left = AVLTree._rebalance(node.left)
node.right = AVLTree._rebalance(node.right)
return AVLTree._rebalance(node)
else:
return node
def _right_rotate(node):
'''
FIXME:
Implement this function.
The lecture videos provide a high-level overview of tree rotations,
and the textbook provides full python code.
The textbook's class hierarchy for their AVL tree code is fairly different from our class hierarchy,
however, so you will have to adapt their code.
'''
if node.left:
if node.left.right:
new_node = Node(node.left.value)
new_node.left = node.left.left
new_node.right = Node(node.value)
new_node.right.left = node.left.right
new_node.right.right = node.right
elif node.left.left:
new_node = Node(node.left.value)
new_node.left = node.left.left
new_node.right = Node(node.value)
new_node.right.right = node.right
else:
new_node = node
else:
new_node = node
return new_node
def _insert(value, node):
'''This code follows essentially the same logic as the BST insert helper function but for this one i needed to rebalance my nodes
Therefore, I created the helper function above to rebalance my nodes'''
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
AVLTree._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
AVLTree._insert(value, node.right)
else:
print("Already in the tree")
#All was well and dandy but this would not give me a balanced AVL tree so i have to balance within the insert helper function
if AVLTree._is_avl_satisfied(
node) == False: #only do this if we are not balanced
node.left = AVLTree.updateBalance(
node.left) #rebalance the left node
node.right = AVLTree.updateBalance(
node.right) #rebalance the right node
return AVLTree.updateBalance(node) #return the whole balanced node
else:
return node
def _insert(node, value):
'''
FIXME:
Implement this function.
'''
if node is None:
return
#if no space, go left (complete tree)
if node.left and node.right:
node.left = Heap._insert(node.left, value)
if node.value > node.left.value:
return Heap._trickle_up(node, value)
if node.left is None:
node.left = Node(value)
#if heap not satisfied, trickle up
if node.value > node.left.value:
return Heap._trickle_up(node, value)
elif node.right is None:
node.right = Node(value)
#if heap not satisfied, tricke up
if node.value > node.right.value:
return Heap._trickle_up(node, value)
return node
def _input(value, node):
'''
FIXME:
Implement this function.
'''
if node.left is None:
new_node = Node(value)
node.left = new_node
elif node.right is None:
new_node = Node(value)
node.right = new_node
else:
left = Heap.size(node.left)
right = Heap.size(node.right)
new_node = node.left if left <= right else node.right
new_node = Heap._input(value, new_node)
if new_node.value < node.value:
tmp = new_node.value
new_node.value = node.value
node.value = tmp
return node
def test__AVLTree_is_avl_satisified0():
avl = AVLTree()
avl.root = Node(0)
avl.root.left = Node(-1)
avl.root.left.left = Node(-2)
assert avl.is_bst_satisfied()
assert not avl.is_avl_satisfied()
def test__AVLTree_is_avl_satisified2():
avl = AVLTree()
avl.root = Node(0)
avl.root.right = Node(1)
avl.root.right.right = Node(2)
assert avl.is_bst_satisfied()
assert not avl.is_avl_satisfied()
def _insert(value, node):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
BST._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
BST._insert(value, node.right)
def insert_helper(node):
if value > node.value:
if node.right is None:
node.right = Node(value)
else:
node.right = insert_helper(node.right)
elif value < node.value:
if node.left is None:
node.left = Node(value)
else:
node.left = insert_helper(node.left)
node = AVLTree._rebalance(node)
return node
def test__AVLTree_is_avl_satisified9():
avl = AVLTree()
avl.root = Node(0)
avl.root.left = Node(-2)
avl.root.left.left = Node(-3)
avl.root.left.left.left = Node(-4)
avl.root.left.left.left.left = Node(-5)
avl.root.left.right = Node(-1)
avl.root.right = Node(2)
avl.root.right.left = Node(1)
avl.root.right.right = Node(3)
avl.root.right.right.right = Node(4)
assert avl.is_bst_satisfied()
assert not avl.is_avl_satisfied()
def insert(self, value):
'''
FIXME:
Implement this function.
The lecture videos provide a high-level overview of how to insert into an AVL tree,
and the textbook provides full python code.
The textbook's class hierarchy for their AVL tree code is fairly different from our class hierarchy,
however, so you will have to adapt their code.
HINT:
It is okay to add @staticmethod helper functions for this code.
The code should look very similar to the code for your insert function for the BST,
but it will also call the left and right rebalancing functions.
'''
def insert_helper(node):
if value > node.value:
if node.right is None:
node.right = Node(value)
else:
node.right = insert_helper(node.right)
elif value < node.value:
if node.left is None:
node.left = Node(value)
else:
node.left = insert_helper(node.left)
node = AVLTree._rebalance(node)
return node
if self.root is None:
self.root = Node(value)
else:
self.root = insert_helper(self.root)
def _insert(node, value):
'''
insert helper function
P.S. I used the following logic https://www.geeksforgeeks.org/avl-tree-set-1-insertion/ and modified accordingly
'''
if node is None:
return Node(value)
elif value < node.value:
node.left = AVLTree._insert(node.left, value)
else:
node.right = AVLTree._insert(node.right, value)
balance = AVLTree._balance_factor(node)
#Left Left
if balance > 1 and value < node.left.value:
return AVLTree._right_rotate(node)
#Right Right
if balance < -1 and value > node.right.value:
return AVLTree._left_rotate(node)
#Left Right
if balance > 1 and value > node.left.value:
node.left = AVLTree._left_rotate(node.left)
return AVLTree._right_rotate(node)
#Right Left
if balance < -1 and value < node.right.value:
node.right = AVLTree._right_rotate(node.right)
return AVLTree._left_rotate(node)
return node
def insert(self, value):
'''
Inserts value into the BST.
'''
if self.root is None:
self.root = Node(value)
else:
BST._insert(value, self.root)
def insert(self, value):
'''
Inserts value into the heap.
'''
if self.root is None:
self.root = Node(value)
self.root.descendents = 1
else:
Heap._insert(self.root, value)
def _insert(value,node):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
AVLTree._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
AVLTree._insert(value, node.right)
if AVLTree._is_avl_satisfied(node) == False:
node.left = AVLTree.rebalance(node.left)
node.right = AVLTree.rebalance(node.right)
return AVLTree.rebalance(node)
else:
return node
def _input(value, node):
if node.left is None:
new_node = Node(value)
node.left = new_node
elif node.right is None:
new_node = Node(value)
node.right = new_node
else:
left = Heap.s1(node.left)
right = Heap.s1(node.right)
new_node = node.left if left <= right else node.right
new_node = Heap._input(value, new_node)
if new_node.value < node.value:
tmp = new_node.value
new_node.value = node.value
node.value = tmp
return node
def _insert(node, value):
'''
FIXME:
Implement this function.
The lecture videos have the exact code you need,
except that their method is an instance method when it should have been a static method.
'''
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
BST._insert(node.left, value)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
BST._insert(node.right, value)
def _right_rotate(node): if node is None or node.left is None: return node newroot = Node(node.left.value) newroot.left = node.left.left new_right = Node(node.value) new_right.right = node.right new_right.left = node.left.right newroot.right = new_right return newroot
def _insert(node, value):
node.descendents += 1
binary = "{0:b}".format(node.descendents)
if binary[1] == '0': # go to left
if node.left is None:
node.left = Node(value)
node.left.descendents = 1
else:
Heap._insert(node.left, value)
if node.value > node.left.value:
node.value, node.left.value = node.left.value, node.value
if binary[1] == '1': # go to right
if node.right is None:
node.right = Node(value)
node.right.descendents = 1
else:
Heap._insert(node.right, value)
if node.value > node.right.value:
node.value, node.right.value = node.right.value, node.value
def _insert(value, node):
'''
DONE - FIXME:
Implement this function.
The lecture videos have the exact code you need,
except that their method is an instance method when it should have been a static method.
'''
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
BST._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
BST._insert(value, node.right)
else:
print("Value is already present in the Tree.")
def _insert(value, node):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
AVLTree._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
AVLTree._insert(value, node.right)
else:
print("Already in the tree")
if AVLTree._is_avl_satisfied(node) == False:
node.left = AVLTree.updateBalance(node.left)
node.right = AVLTree.updateBalance(node.right)
return AVLTree.updateBalance(node)
else:
return node
def _insert(value, node):
if node.value is None:
return Node(node.value)
elif value < node.value:
if node.left is None:
node.left = Node(value)
# AVLTree.rebalance(node.left)
else:
AVLTree._insert(value, node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
# AVLTree.rebalance(node.right)
else:
AVLTree._insert(value, node.right)
else:
print("Value already in tree")
return AVLTree.rebalance(node)
def _insert(node, value):
'''
FIXME:
Implement this function.
'''
if node.left and node.right:
node.left = Heap._insert(node.left, value)
if node.value > node.left.value:
return Heap._upHeapBubble(node, value)
if node.left is None:
node.left = Node(value)
if node.value > node.left.value:
return Heap._upHeapBubble(node, value)
elif node.right is None:
node.right = Node(value)
if node.value > node.right.value:
return Heap._upHeapBubble(node, value)
return node
def test__BST_is_bst_satisified5():
bst = BST()
bst.root = Node(0)
bst.root.left = Node(-2)
bst.root.left.left = Node(-3)
bst.root.left.right = Node(-1)
bst.root.right = Node(2)
bst.root.right.left = Node(1)
bst.root.right.right = Node(3)
assert bst.is_bst_satisfied()
def test__Heap_is_heap_satisified1():
heap = Heap()
heap.root = Node(0)
heap.root.left = Node(2)
heap.root.left.left = Node(2)
heap.root.left.right = Node(5)
heap.root.right = Node(0)
heap.root.right.left = Node(0)
heap.root.right.right = Node(30)
assert heap.is_heap_satisfied()
def test__Heap_is_heap_satisified6():
heap = Heap()
heap.root = Node(0)
heap.root.left = Node(2)
heap.root.left.left = Node(3)
heap.root.left.right = Node(5)
heap.root.right = Node(1)
heap.root.right.left = Node(4)
heap.root.right.right = Node(-1)
assert not heap.is_heap_satisfied()
def _insert(value, node):
node.descendents += 1
binary = "{0:b}".format(node.descendents)
if binary[1] == '0':
if node.left is None:
node.left = Node(value)
node.left.descendents = 1
else:
Heap._insert(value, node.left)
if node.value > node.left.value:
node.value, node.left.value = node.left.value, node.value
elif binary[1] == '1':
if node.right is None:
node.right = Node(value)
node.right.descendents = 1
else:
Heap._insert(value, node.right)
if node.value > node.right.value:
node.value, node.right.value = node.right.value, node.value
return node
def _left_rotate(node):
'''
FIXME:
Implement this function.
The lecture videos provide a high-level overview of tree rotations,
and the textbook provides full python code.
The textbook's class hierarchy for their AVL tree code is fairly different from our class hierarchy,
however, so you will have to adapt their code.
'''
if node is None or node.right is None:
return node
node1 = Node(node.right.value)
node1.right = node.right.right
leftNode = Node(node.value)
leftNode.left = node.left
leftNode.right = node.right.left
node1.left = leftNode
return node1
def insert(self, value): if self.root is None: self.root = Node(value) else: self.root = AVLTree._insert(value, self.root)