Python Tutorial

A red-black tree is a binary search tree with the additional property of being "nearly" adjusted. Every node in a red-black tree has a color, either red or black, and these colors are utilized to keep up with balance during insertions and deletions.

Deletion:

BST Deletion:

Begin by finding the node you need to erase utilizing standard BST deletion. Assuming the node has one or no children, eliminate it and supplant it with its child (if any).

Save the shade of the node to be erased, as it will be required later to decide if to apply the "erase fix."

Fix Violations (Erase Fix):

Like insertion, deletion could disregard red-black tree properties, especially the double-black property. You want to play out a progression of recoloring, rotation, and substitution tasks known as the "erase fix."

Decide the side (left or right) from which the node was erased and whether the kin (sibling) of the node is red or black.
Assuming the kin is red, perform rotations and recoloring to change the issue into one of the different cases.
If the kin is black and both of its children are black or invalid, recolor the kin as red and spread the double black issue upwards.
Assuming the kin is black and has something like one red child, perform rotations and recoloring to change over the issue into the following case.
Rehash these means while climbing the tree until the double black is spread out of the root or the violation is settled.

Code

# Python code for Red-Black Tree deletion
class Node:
    def __init__(self, key, color='R'):
        self.key = key
        self.color = color
        self.left = None
        self.right = None
        self.parent = None

class RedBlackTree:
    def __init__(self):
        self.TNULL = Node(None)
        self.root = self.TNULL

    def left_rotate(self, x):
        y = x.right
        x.right = y.left
        if y.left != self.TNULL:
            y.left.parent = x
        y.parent = x.parent
        if x.parent is None:
            self.root = y
        elif x == x.parent.left:
            x.parent.left = y
        else:
            x.parent.right = y
        y.left = x
        x.parent = y

    def right_rotate(self, y):
        x = y.left
        y.left = x.right
        if x.right != self.TNULL:
            x.right.parent = y
        x.parent = y.parent
        if y.parent is None:
            self.root = x
        elif y == y.parent.left:
            y.parent.left = x
        else:
            y.parent.right = x
        x.right = y
        y.parent = x

    def insert(self, key):
        new_node = Node(key)
        new_node.parent = None
        new_node.key = key
        new_node.left = self.TNULL
        new_node.right = self.TNULL
        new_node.color = 'R'

        y = None
        x = self.root

        while x != self.TNULL:
            y = x
            if new_node.key < x.key:
                x = x.left
            else:
                x = x.right

        new_node.parent = y

        if y is None:
            self.root = new_node
        elif new_node.key < y.key:
            y.left = new_node
        else:
            y.right = new_node

        if new_node.parent is None:
            new_node.color = 'B'
            return

        if new_node.parent.parent is None:
            return

        self.insert_fix(new_node)

    def insert_fix(self, k):
        while k.parent.color == 'R':
            if k.parent == k.parent.parent.right:
                u = k.parent.parent.left
                if u.color == 'R':
                    u.color = 'B'
                    k.parent.color = 'B'
                    k.parent.parent.color = 'R'
                    k = k.parent.parent
                else:
                    if k == k.parent.left:
                        k = k.parent
                        self.right_rotate(k)
                    k.parent.color = 'B'
                    k.parent.parent.color = 'R'
                    self.left_rotate(k.parent.parent)
            else:
                # Similar case for the right side
                pass

        self.root.color = 'B'

    def search(self, key, node=None):
        if node is None:
            node = self.root
        while node != self.TNULL and key != node.key:
            if key < node.key:
                node = node.left
            else:
                node = node.right
        return node

    def transplant(self, u, v):
        if u.parent is None:
            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 delete(self, key):
        z = self.search(key)
        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 == 'B':
            self.delete_fix(x)

    def delete_fix(self, x):
        while x != self.root and x.color == 'B':
            if x == x.parent.left:
                w = x.parent.right
                if w.color == 'R':
                    w.color = 'B'
                    x.parent.color = 'R'
                    self.left_rotate(x.parent)
                    w = x.parent.right
                if w.left.color == 'B' and w.right.color == 'B':
                    w.color = 'R'
                    x = x.parent
                else:
                    if w.right.color == 'B':
                        w.left.color = 'B'
                        w.color = 'R'
                        self.right_rotate(w)
                        w = x.parent.right
                    w.color = x.parent.color
                    x.parent.color = 'B'
                    w.right.color = 'B'
                    self.left_rotate(x.parent)
                    x = self.root
            else:
                # Similar case for the right-side
                pass

        x.color = 'B'

# Example usage
rb_tree = RedBlackTree()
rb_tree.insert(55)
rb_tree.insert(40)
rb_tree.insert(65)

# Perform deletions
rb_tree.delete(40)
rb_tree.delete(65)

Output:

The initial starting tree: