Python Code for Red-Black Tree

Data structures are fundamental parts of software engineering and programming that help coordinate and store data proficiently. Among these designs, the red-black tree stands apart as a fair binary search tree that keeps up with its equilibrium through a bunch of rules and rotations. In this initial segment of our article, we'll dig into the idea of red-black trees and their importance in overseeing data.

Red-Black Trees

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. The essential objective of a red-black tree is to guarantee that no way from the root node to any leaf node is fundamentally longer than some other way. This property ensures a logarithmic level, prompting proficient search, insertion, and deletion tasks.

Balancing with Color and Rotations

The five key properties that a red-black tree should fulfill are:

Each node is either red or black.
The root node is generally black.
Red nodes can't have red children (no back-to-back red nodes in a way).
Each way from a node to its relative null nodes should contain a similar number of black nodes (black-level property).
New nodes are at first colored red.

To keep up with these properties, red-black trees use rotation tasks: left rotations and right rotations. These rotations assist with rebuilding the tree while important, guaranteeing that the equilibrium is protected after insertions or deletions.

Red-Black Tree Insertion Algorithm:

Begin at the root of the tree.
Traverse the tree descending, following the binary search tree property, to track down the suitable area for the new node insertion.
Embed the new node as a red leaf node.
Fix any infringement of the red-black tree properties that might have been presented by the insertion utilizing a bunch of rotation and recoloring tasks.

Code

# Python code for Red-Black Tree
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

    # ... Other methods like fix_violation

# Create a red-black tree instance
rb_tree = RedBlackTree()

# Insert nodes
def insert_and_display(key):
    rb_tree.insert(key)
    print(f"Inserted {key}. Tree colors:")
    display_colors(rb_tree.root)
    print()

def display_colors(node):
    if node != rb_tree.TNULL:
        display_colors(node.left)
        print(f"Node {node.key} color: {node.color}")
        display_colors(node.right)

# Insert nodes and display colors
insert_and_display(55)
insert_and_display(40)
insert_and_display(65)
insert_and_display(60)
insert_and_display(75)
insert_and_display(57)

# Output the structure of the tree
print("\nFinal Tree Structure:")
display_tree_structure(rb_tree.root, 0)

def display_tree_structure(node, level):
    if node != rb_tree.TNULL:
        display_tree_structure(node.right, level + 1)
        print("  " * level, node.key, node.color)
        display_tree_structure(node.left, level + 1)

Explanation:

Step 1: Start at the root of the tree and move descending as you would in a binary search tree to track down the suitable spot for insertion.

Step 2: Traverse the tree in light of the examination of the new node's key with the keys of the current nodes. If the key is more modest, move to the left youngster; assuming the key is bigger, move to the right kid.

Step 3: Supplement the new node as a red leaf node. Since red nodes don't disregard the property of no sequential red nodes, embedding a red node as a leaf will not promptly disregard any properties.

Step 4: After insertion, you could have to play out a progression of rotations and recoloring to keep up with the five properties of a red-black tree. These activities incorporate left and right rotations to adjust the tree and recoloring to guarantee no continuous red nodes and to keep up with the black-level property.

Time Complexity:

The time complexity of the insertion activity in a red-black tree is O(log n), where n is the number of nodes in the tree. This is because the tree stays adjusted, and the insertion activity just includes navigating the tree descending along a solitary way.

Space Complexity:

The space complexity of the insertion activity in a red-black tree is O(1), as no extra memory is expected to play out the insertion activity itself. The space complexity for the general red-black tree structure is O(n), where n is the quantity of nodes, because of the stockpiling of the nodes in memory.

Next TopicQuickSort using Random Pivoting using Python

← prev next →