def _insert(node, value, insert_path):
'''
Helper function for insert
'''
# insert value
if insert_path[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, insert_path[1:])
if insert_path[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, insert_path[1:])
# swap
if insert_path[0] == '0':
if node.left.value < node.value:
temp = node.value
node.value = node.left.value
node.left.value = temp
return node
else:
return node
if insert_path[0] == '1':
if node.right.value < node.value:
temp = node.value
node.value = node.right.value
node.right.value = temp
return node
else:
return node
def _insert(node, value, numlist):
if numlist[0] == '0':
if node.left is None:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, numlist[1:])
if numlist[0] == '1':
if node.right is None:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, numlist[1:])
if numlist[0] == '0':
if node.left.value < node.value:
newnode = node.value
node.value = node.left.value
node.left.value = newnode
return node
else:
return node
if numlist[0] == '1':
if node.right.value < node.value:
newnode = node.value
node.value = node.right.value
node.right.value = newnode
return node
else:
return node
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 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 _insert(node, value, line):
'''
'''
if line[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, line[1:])
if line[0] == '0':
if node.left.value < node.value:
tmp = node.value
node.value = node.left.value
node.left.value = tmp
return node
else:
return node
if line[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, line[1:])
if line[0] == '1':
if node.right.value < node.value:
tmp = node.value
node.value = node.right.value
node.right.value = tmp
return node
else:
return node
def _insert(node, value, binarycount):
if binarycount[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, binarycount[1:])
if binarycount[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, binarycount[1:])
if binarycount[0] == '0':
if node.left.value < node.value:
switch = node.value
node.value = node.left.value
node.left.value = switch
return node
else:
return node
if binarycount[0] == '1':
if node.right.value < node.value:
switch = node.value
node.value = node.right.value
node.right.value = switch
return node
else:
return node
def _insert(node, position, value):
if position[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, position[1:], value)
if position[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, position[1:], value)
if position[0] == '0':
if node.value > node.left.value:
tempval = node.value
node.value = node.left.value
node.left.value = tempval
return node
else:
return node
if position[0] == '1':
if node.value > node.right.value:
tempval = node.value
node.value = node.right.value
node.right.value = tempval
return node
else:
return node
def _remove(node, value):
if node is None:
return
if value > node.value and node.right:
node.right = BST._remove(node.right, value)
return node
elif value < node.value and node.left:
node.left = BST._remove(node.left, value)
return node
elif value == node.value:
if node.left is None and node.right is None:
return None
elif node.left is None:
return node.right
elif node.right is None:
return node.left
else:
smallest = BST._find_smallest(node.right)
if smallest == node.right.value:
ret = node.right
ret.left = node.left
else:
ret = Node(smallest)
ret.left = node.left
ret.right = BST._remove(node.right, smallest)
return ret
else:
return node
def _insert(value, node, binarynum):
if binarynum[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(value, node.left, binarynum[1:])
if binarynum[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(value, node.right, binarynum[1:])
if binarynum[0] == '0':
if node.left.value < node.value:
temp = node.value
node.value = node.left.value
node.left.value = temp
return node
else:
return node
if binarynum[0] == '1':
if node.right.value < node.value:
temp = node.value
node.value = node.right.value
node.right.value = temp
return node
else:
return node
def _insert(node, value, insert_p):
if insert_p[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, insert_p[1:])
if insert_p[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, insert_p[1:])
if insert_p[0] == '1':
if node.right.value < node.value:
placeholder = node.value
node.value = node.right.value
node.right.value = placeholder
return node
else:
return node
if insert_p[0] == '0':
if node.left.value < node.value:
placeholder = node.value
node.value = node.left.value
node.left.value = placeholder
return node
else:
return node
def _insert(node, value, insert_path):
if insert_path[0] == '0':
if not node.left:
node.left = Node(value)
else:
node.left = Heap._insert(node.left, value, insert_path[1:])
if insert_path[0] == '1':
if not node.right:
node.right = Node(value)
else:
node.right = Heap._insert(node.right, value, insert_path[1:])
if insert_path[0] == '0':
if node.left.value < node.value:
x = node.value
node.value = node.left.value
node.left.value = x
return node
else:
return node
if insert_path[0] == '1':
if node.right.value < node.value:
x = node.value
node.value = node.right.value
node.right.value = x
return node
else:
return node
def _left_rotate(node):
if node is None or node.right is None:
return node
new = Node(node.right.value)
new.right = node.right.right
new.left = Node(node.value)
new.left.left = node.left
if node.right.left:
new.left.right = node.right.left
return new
def _right_rotate(node):
if node is None or node.left is None:
return node
new_root = Node(node.left.value)
new_root.left = node.left.left
new_root.right = Node(node.value)
new_root.right.right = node.right
if node.left.right:
new_root.right.left = node.left.right
return new_root
def _insert_helper(node, value):
if node.value > value:
if node.left:
BST._insert_helper(node.left, value)
else:
node.left = Node(value)
elif node.value < value:
if node.right:
BST._insert_helper(node.right, value)
else:
node.right = Node(value)
def _insert(value, path, lbinrep):
if len(lbinrep) == 1:
if lbinrep[0] == 1:
path.right = Node(value)
if lbinrep[0] == 0:
path.left = Node(value)
else:
if lbinrep[0] == 1:
Heap._insert(value, path.right, lbinrep[1:])
if lbinrep[0] == 0:
Heap._insert(value, path.left, lbinrep[1:])
def _insert(value, node):
if value < node.value:
if node.left:
BST._insert(value, node.left)
else:
node.left = Node(value)
elif value > node.value:
if node.right:
BST._insert(value, node.right)
else:
node.right = Node(value)
def _insert(value, pos_bin, node):
if pos_bin:
if pos_bin[0] == '0':
if node.left:
Heap._insert(value, pos_bin[1:], node.left)
else:
node.left = Node(value)
else:
if node.right:
Heap._insert(value, pos_bin[1:], node.right)
else:
node.right = Node(value)
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)
else:
return None
def _insert(value, node):
if value < node.value:
if node.left:
return AVLTree._insert(value, node.left)
else:
node.left = Node(value)
elif value > node.value:
if node.right:
return AVLTree._insert(value, node.right)
else:
node.right = Node(value)
else:
return
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)
else:
print("value is already present in tree")
def _insert(value, node):
if value > node.value:
if node.right is None:
node.right = Node(value)
else:
BST._insert(value, node.right)
elif value < node.value:
if node.left is None:
node.left = Node(value)
else:
BST._insert(value, node.left)
elif value == node.value:
print("value already in the tree - duplicate")
def _insert(root: Node, number: int):
if root is None:
root = Node(number)
return root
else:
if root.value == number:
return root
elif number < root.value:
root.left = BST._insert(root.left, number)
else:
root.right = BST._insert(root.right, number)
return root
def _insert(value, node):
if value < node.value:
if not node.left:
node.left = Node(value)
else:
BST._insert(value, node.left)
elif value > node.value:
if not node.right:
node.right = Node(value)
else:
BST._insert(value, node.right)
else:
print("Cannot insert value")
def _insert(value, node):
if node.value >= value:
if node.left:
BST._insert(value, node.left)
else:
node.left = Node(value)
return
elif node.value < value:
if node.right:
BST._insert(value, node.right)
else:
node.right = Node(value)
return
def _insert(node, value):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
BST._insert(node.left, value)
if value > node.value:
if node.right is None:
node.right = Node(value)
else:
BST._insert(node.right, value)
if value == node.value:
pass
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)
else:
print("Value in Tree")
def go(node):
if value < node.value:
if node.left is None:
node.left = Node(value)
else:
node.left = go(node.left)
elif value > node.value:
if node.right is None:
node.right = Node(value)
else:
node.right = go(node.right)
node = AVLTree._rebalance(node)
return node
def _insert(value, node):
if value < node.value:
if node.left:
BST._insert(value, node.left)
else:
node.left = Node(value)
elif value > node.value:
if node.right:
BST._insert(value, node.right)
else:
node.right = Node(value)
else:
print('Value already in BST.')
def _insert(node, value):
'''
Helper function for insert
'''
if node.value < value:
if node.right is not None:
BST._insert(node.right, value)
else:
node.right = Node(value)
elif node.value > value:
if node.left is not None:
BST._insert(node.left, value)
else:
node.left = Node(value)
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
new = Node(node.right.value)
new.right = node.right.right
leftnode = Node(node.value)
leftnode.left = node.left
leftnode.right = node.right.left
new.left = leftnode
return new
