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)