Red black tree

class Node:

def __init__(self, value, color="red"):

self.value = value

self.color = color # 'red' or 'black'

self.left = None

self.right = None

self.parent = None

class RedBlackTree:

def __init__(self):

self.TNULL = Node(0, color="black") # Null leaf node

self.root = self.TNULL

def insert(self, value):

new_node = Node(value)

new_node.left = self.TNULL

new_node.right = self.TNULL

new_node.color = "red"

parent = None

current = self.root

while current != self.TNULL:

if new_node.value < current.value:

current = current.left

else:

current = current.right

new_node.parent = parent

if not parent:

self.root = new_node

elif new_node.value < parent.value:

parent.left = new_node

else:

parent.right = new_node

self.fix_insert(new_node)

def fix_insert(self, k):

while k.parent and k.parent.color == "red":

if k.parent == k.parent.parent.right:

u = k.parent.parent.left # Uncle node

if u and u.color == "red": # Case 1: Uncle is red

u.color = "black"

k.parent.color = "black"

k.parent.parent.color = "red"

k = k.parent.parent
 else:

if k == k.parent.left: # Case 2: k is left child

k = k.parent

self.rotate_right(k)

k.parent.color = "black" # Case 3: Recolor and rotate

k.parent.parent.color = "red"

self.rotate_left(k.parent.parent)

else:

u = k.parent.parent.right # Uncle node

if u and u.color == "red": # Case 1: Uncle is red

u.color = "black"

k.parent.color = "black"

k.parent.parent.color = "red"

k = k.parent.parent

else:

if k == k.parent.right: # Case 2: k is right child

k = k.parent

self.rotate_left(k)

k.parent.color = "black" # Case 3: Recolor and rotate

k.parent.parent.color = "red"

self.rotate_right(k.parent.parent)

if k == self.root:

break

self.root.color = "black"
def delete(self, value):

self.delete_node_helper(self.root, value)

def delete_node_helper(self, node, key):

z = self.TNULL

while node != self.TNULL:

if node.value == key:

z = node

if node.value <= key:

node = node.right

else:

node = node.left

if z == self.TNULL:

print("Value not found in tree")

return

y=z

y_original_color = y.color

if z.left == self.TNULL:

x = z.right

self.transplant(z, z.right)

elif z.right == self.TNULL:

x = z.left

self.transplant(z, z.left)
 else:

y = self.minimum(z.right)

y_original_color = y.color

x = y.right

if y.parent == z:

x.parent = y

else:

self.transplant(y, y.right)

y.right = z.right

y.right.parent = y

self.transplant(z, y)

y.left = z.left

y.left.parent = y

y.color = z.color

if y_original_color == "black":

self.fix_delete(x)

def fix_delete(self, x):

while x != self.root and x.color == "black":

if x == x.parent.left:

s = x.parent.right

if s.color == "red":

s.color = "black"
 x.parent.color = "red"

self.rotate_left(x.parent)

s = x.parent.right

if s.left.color == "black" and s.right.color == "black":

s.color = "red"

x = x.parent

else:

if s.right.color == "black":

s.left.color = "black"

s.color = "red"

self.rotate_right(s)

s = x.parent.right

s.color = x.parent.color

x.parent.color = "black"

s.right.color = "black"

self.rotate_left(x.parent)

x = self.root

else:

s = x.parent.left

if s.color == "red":

s.color = "black"

x.parent.color = "red"

self.rotate_right(x.parent)
 s = x.parent.left

if s.left.color == "black" and s.right.color == "black":

s.color = "red"

x = x.parent

else:

if s.left.color == "black":

s.right.color = "black"

s.color = "red"

self.rotate_left(s)

s = x.parent.left

s.color = x.parent.color

x.parent.color = "black"

s.left.color = "black"

self.rotate_right(x.parent)

x = self.root

x.color = "black"

def rotate_left(self, x):

y = x.right

x.right = y.left

if y.left != self.TNULL:

y.left.parent = x
 y.parent = x.parent

if not x.parent:

self.root = y

elif x == x.parent.left:

x.parent.left = y

else:

x.parent.right = y

y.left = x

x.parent = y

def rotate_right(self, x):

y = x.left

x.left = y.right

if y.right != self.TNULL:

y.right.parent = x

y.parent = x.parent

if not x.parent:

self.root = y

elif x == x.parent.right:

x.parent.right = y

else:

x.parent.left = y

y.right = x

x.parent = y
 def transplant(self, u, v):

if not u.parent:

self.root = v

elif u == u.parent.left:

u.parent.left = v

else:

u.parent.right = v

v.parent = u.parent

def minimum(self, node):

while node.left != self.TNULL:

node = node.left

return node

def inorder(self, node):

if node != self.TNULL:

self.inorder(node.left)

print(node.value, end=" ")

self.inorder(node.right)

# Usage

tree = RedBlackTree()

values = [15, 25, 10, 5, 1, 30, 25]

tree.insert(value)

print("Inorder traversal after insertion:")

tree.inorder(tree.root)

print("\nDeleting 10...")

tree.delete(10)

print("Inorder traversal after deletion:")

tree.inorder(tree.root)
After deletion of 10

AVL tree

class Node:

def __init__(self, value):

self.value = value

self.left = None

self.right = None

self.height = 1

class AVLTree:

def get_height(self, node):

if not node:

return 0

return node.height

def get_balance(self, node):

if not node:
 return 0

return self.get_height(node.left) - self.get_height(node.right)

def rotate_right(self, y):

x = y.left

T2 = x.right

x.right = y

y.left = T2

y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))

x.height = 1 + max(self.get_height(x.left), self.get_height(x.right))

return x

def rotate_left(self, x):

y = x.right

T2 = y.left

y.left = x

x.right = T2

x.height = 1 + max(self.get_height(x.left), self.get_height(x.right))

y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))

def insert(self, root, value):

if not root:

return Node(value)

elif value < root.value:

root.left = self.insert(root.left, value)

else:

root.right = self.insert(root.right, value)

root.height = 1 + max(self.get_height(root.left), self.get_height(root.right))

balance = self.get_balance(root)

# Left Left Case

if balance > 1 and value < root.left.value:

return self.rotate_right(root)

# Right Right Case

if balance < -1 and value > root.right.value:

return self.rotate_left(root)

# Left Right Case

if balance > 1 and value > root.left.value:

root.left = self.rotate_left(root.left)
 return self.rotate_right(root)

# Right Left Case

if balance < -1 and value < root.right.value:

root.right = self.rotate_right(root.right)

return self.rotate_left(root)

return root

def min_value_node(self, node):

current = node

while current.left:

current = current.left

return current

def delete(self, root, value):

if not root:

return root

if value < root.value:

root.left = self.delete(root.left, value)

elif value > root.value:

root.right = self.delete(root.right, value)

else:

if not root.left:
 return root.right

elif not root.right:

return root.left

temp = self.min_value_node(root.right)

root.value = temp.value

root.right = self.delete(root.right, temp.value)

root.height = 1 + max(self.get_height(root.left), self.get_height(root.right))

balance = self.get_balance(root)

# Left Left Case

if balance > 1 and self.get_balance(root.left) >= 0:

return self.rotate_right(root)

# Left Right Case

if balance > 1 and self.get_balance(root.left) < 0:

root.left = self.rotate_left(root.left)

return self.rotate_right(root)

# Right Right Case

if balance < -1 and self.get_balance(root.right) <= 0:

return self.rotate_left(root)
 # Right Left Case

if balance < -1 and self.get_balance(root.right) > 0:

root.right = self.rotate_right(root.right)

return self.rotate_left(root)

return root

def inorder(self, root):

if not root:

return

self.inorder(root.left)

print(root.value, end=" ")

self.inorder(root.right)

# Usage

avl_tree = AVLTree()

root = None

values = [20, 60, 80, 100, 120, 70]

# Insert nodes

for value in values:

root = avl_tree.insert(root, value)

print("Inorder traversal after insertion:")

# Delete nodes

print("\n\nDeleting 60...")

root = avl_tree.delete(root, 60)

print("Inorder traversal after deleting 60:")

avl_tree.inorder(root)

print("\n\nDeleting 80...")

root = avl_tree.delete(root, 80)

print("Inorder traversal after deleting 80:")

avl_tree.inorder(root)

After inserting 20:

Root: 20

After inserting 60:

Root: 20

R--- 60

After inserting 80:

Root: 60

L--- 20

R--- 80

After inserting 100:

Root: 60

L--- 20
R--- 80

R--- 100

After inserting 120:

Root: 60

L--- 20

R--- 100

L--- 80

R--- 120

After inserting 70:

Root: 80

L--- 60

L--- 20

R--- 70

R--- 100

R--- 120

After deleting 60:

Root: 80

L--- 70

L--- 20

R--- 100

R--- 120

After deleting 80:

Root: 100

L--- 70

L--- 20
R--- 120