COMPUTER SCIENCE DEPARTMENT

DATA STRUCTURES AND

ALGORITHMS
ASSIGNMENT # 4

NAME: Malik Huzaifa

CLASS: BSCS-4A
ROLL NO: R1F22UBSCS043
Submitted to:
Prof Saira Mazhar
 ➢ Definitions

a) Define what a self-balancing tree is. Why are self-balancing trees important in computer science?

A self-balancing tree is a binary search tree (BST) that automatically keeps its height (maximum number of edges from
the root to a leaf) as small as possible after insertions and deletions. This ensures that the operations like insertion,
deletion, and searching can be performed efficiently.

Importance in Computer Science:

Self-balancing trees are crucial in computer science because they maintain O(log n) time complexity for insertion,
deletion, and lookup operations. This efficiency is essential for performance-critical applications like databases, file
systems, and network routers, where maintaining quick access to data is paramount. Without self-balancing
mechanisms, a BST can degenerate into a linear structure (like a linked list) in the worst-case scenario, leading to O(n)
time complexity for operations, which is undesirable.

b) Briefly explain the key properties that make Red-Black trees self-balancing.

Red-Black trees are a type of self-balancing BST with specific properties that enforce balance through color coding and
structural rules:

1. Node Colors:
Each node in a Red-Black tree is colored either red or black.

2. Root Property:
The root of the tree is always black.

3. Red Property:
Red nodes cannot have red children, ensuring that red nodes always have black children, preventing two consecutive
red nodes (no double-red).

4. Black Height Property:

Every path from a node to its descendant leaves must have the same number of black nodes, known as the black
height.

5. Leaf Property:
All leaf nodes (null or NIL nodes used for simplification) are black.

These properties ensure that the tree remains balanced, maintaining a logarithmic height and facilitating efficient
operations.

➢ Tree Formation
a) Describe the steps involved in forming a Red-Black tree

Steps to Form a Red-Black Tree:

1. Start with an Empty Tree:

Begin with an empty tree with the root initially set to null.
 2. Insert Nodes:
Insert nodes one by one following the standard BST insertion rules. Initially, all newly inserted nodes are colored red.

3. Check Properties:
After each insertion, check the Red-Black properties to ensure they are not violated, particularly the Red Property (no
two consecutive red nodes) and the Black Height Property (consistent black heights).

4. Recoloring and Rotations:

If any properties are violated:
• Recoloring: Change the colors of nodes to maintain properties.
• Rotations: Perform rotations (left or right) to restore the tree’s balance.

5. Update Root:
Always ensure that the root remains black. This may require a final recoloring after rebalancing.

6. Repeat Process:
Continue this process for each insertion to maintain the tree’s balance and adherence to Red-Black properties.

➢ Insertion Process
a) Explain the insertion process in a Red-Black tree. How does the tree maintain its balance and color properties
after each insertion?

Insertion Process in a Red-Black Tree:

1. Standard BST Insertion:

Insert the new node into the tree following the binary search tree rules. Initially, the new node is colored red.

2. Check for Double Red:

After inserting a red node, if the parent node is also red, it violates the Red Property (no two consecutive red nodes).

3. Fixing Violations:
There are three cases to fix, depending on the uncle node’s color:

- Case 1: Uncle is Red:

Perform recoloring. Change the parent and uncle to black, and the grandparent to red. Then, move up to the
grandparent to check for further violations.
- Case 2: Uncle is Black and Triangle Formed:
Perform a rotation to transform the tree into a linear form. For instance, if the node is the right child of the left child,
perform a left rotation on the parent.
- Case 3: Uncle is Black and Linear Formed:
Perform a rotation to balance the tree. For instance, if the node is the right child of the right child, perform a left
rotation on the grandparent.

4. Recolor and Rotate:

Apply the necessary rotations and recolor nodes to restore Red-Black properties. Ensure the root is black at the end of
the process.

5. Repeat for Each Node:

Continue inserting nodes and fixing any property violations until the tree is balanced.
Example of Insertion and Rebalancing:

Suppose we insert nodes into a Red-Black tree in the order: 10, 20, 30.

1. Insert 10:

- Tree: `10` (Black, since it's the root).

2. Insert 20:

Tree:

10 (Black)
\
20 (Red)

No violation occurs.

3. Insert 30:

Tree:

10 (Black)
\
20 (Red)
\
30 (Red)

- Violation occurs (two consecutive red nodes: 20 and 30).

- Fix: Perform a left rotation on 20.
Resulting Tree:

20 (Black)
/ \
10 (Red) 30 (Red)

The tree is now balanced and maintains Red-Black properties.

➢ Comparison
a) Compare the AVL trees to Red-Black trees in terms of their balancing strategies and operations. Which tree
generally requires more rotations to maintain balance?

Balancing Strategies

• AVL Trees:
- AVL trees maintain strict balance by ensuring the height difference between the left and right subtrees of any node
is at most 1.
- This strict balance often leads to shorter trees compared to Red-Black trees.
- They achieve balance through rotations after every insertion and deletion to keep the height difference within the
limit.
 • Red-Black Trees:
- Red-Black trees use a more relaxed balance approach based on coloring rules and the properties mentioned.
- They allow for a height difference but ensure that the tree height remains logarithmic.
- Balancing involves both recoloring and rotations, which can lead to fewer rotations compared to AVL trees but
with potentially taller trees.

Operations and Rotations

• AVL Trees:
- Operations like insertion and deletion may require multiple rotations to restore balance.
- AVL trees typically require more rotations because they maintain a stricter balance.

• Red-Black Trees:
- Operations generally involve fewer rotations because they use both recoloring and rotations to maintain balance.
- The more relaxed balancing criteria usually result in a higher but balanced tree with fewer rotations overall.

Which Requires More Rotations?

• AVL Trees usually require more rotations to maintain their stricter balance criterion. This is because AVL trees
need to immediately restore the height balance after any insertion or deletion, often necessitating multiple
rotations.
• Red-Black Trees , on the other hand, may perform fewer rotations due to their more flexible balancing rules,
relying partly on recoloring to maintain their properties.

Summary:

In summary, while both AVL and Red-Black trees are efficient self-balancing BSTs, they differ in their balancing
strategies. AVL trees provide stricter height balance, resulting in shorter trees but requiring more rotations. Red-Black
trees offer a more flexible balance with fewer rotations and potentially taller structures, making them suitable for
applications where frequent insertions and deletions occur.

These explanations should provide a comprehensive understanding of Red-Black trees and how they compare to AVL
trees in terms of their self-balancing mechanisms and operations.