ITAI SHURO R206319W

AlEXANDER W. D. SIBANDA R1811309N

TATENDA MAJIRA R202025Q

HCSCI 238-Design and Analysis of Algorithms Assignment

1)Red-Black Tree
a)Inserting an element into a Red-Black Tree
While inserting a new node, the new node is always inserted as a RED node. After insertion of a new
node, if the tree is violating the properties of the red-black tree then, we do the following
operations.

1. Recolour
2. Rotation

Algorithm to insert a node

Following steps are followed for inserting a new element into a red-black tree:

1. Let y be the leaf (ie. NIL) and x be the root of the tree.

2. Check if the tree is empty (ie. whether x is NIL). If yes, insert newNode as a root
node and color it black.
3. Else, repeat steps following steps until leaf (NIL) is reached.
0. Compare newKey with rootKey.
a. If newKey is greater than rootKey, traverse through the right subtree.
b. Else traverse through the left subtree.

4. Assign the parent of the leaf as a parent of newNode.

5. If leafKey is greater than newKey, make newNode as rightChild.
6. Else, make newNode as leftChild.
7. Assign NULL to the left and rightChild of newNode.
8. Assign RED color to newNode.
9. Call InsertFix-algorithm to maintain the property of red-black tree if violated.

Algorithm to maintain red-black property after insertion

This algorithm is used for maintaining the property of a red-black tree if the
insertion of a newNode violates this property.

1. Do the following while the parent of newNode p is RED.

2. If p is the left child of grandParent gP of z, do the following.
Case-I:
0. If the color of the right child of gP of z is RED, set the color of both the
children of gP as BLACK and the color of gP as RED.
a. Assign gP to newNode.
Case-II:
b. Else if newNode is the right child of p then, assign p to newNode.
c. Left-Rotate newNode.
Case-III:
d. Set color of p as BLACK and color of gP as RED.
e. Right-Rotate gP.
3. Else, do the following.

0. If the color of the left child of gP of z is RED, set the color of both the children
of gP as BLACK and the color of gP as RED.
a. Assign gP to newNode.
b. Else if newNode is the left child of p then, assign p to newNode and Right-
Rotate newNode.
c. Set color of p as BLACK and color of gP as RED.
d. Left-Rotate gP.
4. Set the root of the tree as BLACK.

b)Deleting an element from a Red-Black Tree

This operation removes a node from the tree. After deleting a node, the red-black property
is maintained again.

Algorithm to delete a node

 1. Save the color of nodeToBeDeleted in origrinalColor.
2. If the left child of nodeToBeDeleted is NULL
0. Assign the right child of nodeToBeDeleted to x.
a. Transplant nodeToBeDeleted with x.
3. Else if the right child of nodeToBeDeleted is NULL
0. Assign the left child of nodeToBeDeleted into x.
a. Transplant nodeToBeDeleted with x.
4. Else

0. Assign the minimum of right subtree of noteToBeDeleted into y.

a. Save the color of y in originalColor.
b. Assign the rightChild of y into x.
c. If y is a child of nodeToBeDeleted, then set the parent of x as y.
d. Else, transplant y with rightChild of y.
e. Transplant nodeToBeDeleted with y.
f. Set the color of y with originalColor.

5. If the originalColor is BLACK, call DeleteFix(x).

Algorithm to maintain Red-Black property after deletion.

 Do the following until the x is not the root of the tree and the color of x is BLACK
 If x is the left child of its parent, then,
a. Assign w to the sibling of x.

b. If the right child of parent of x is RED,

Case-I:
0. Set the color of the right child of the parent of x as BLACK.
a. Set the color of the parent of x as RED.
b. Left-Rotate the parent of x.
c. Assign the rightChild of the parent of x to w.
c. If the color of both the right and the leftChild of w is BLACK,
Case-II:
 0. Set the color of w as RED
a. Assign the parent of x to x.
d. Else if the color of the rightChild of w is BLACK
Case-III:
0. Set the color of the leftChild of w as BLACK
a. Set the color of w as RED
b. Right-Rotate w.
c. Assign the rightChild of the parent of x to w.
e. If any of the above cases do not occur, then do the following.
Case-IV:
0. Set the color of w as the color of the parent of x.
a. Set the color of the parent of x as BLACK.
b. Set the color of the right child of w as BLACK.
c. Left-Rotate the parent of x.
d. Set x as the root of the tree.
 Else the same as above with right changed to left and vice versa.
 Set the color of x as BLACK.

The Code for the implementation in Python

# Implementing Red-Black Tree in Python
import sys
# Node creation
class Node():
def __init__(self, item):
self.item = item
self.parent = None
self.left = None
self.right = None
self.color = 1

class RedBlackTree():
def __init__(self):
self.TNULL = Node(0)
self.TNULL.color = 0
self.TNULL.left = None
self.TNULL.right = None
self.root = self.TNULL
# Preorder
def pre_order_helper(self, node):
if node != TNULL:
sys.stdout.write(node.item + " ")
self.pre_order_helper(node.left)
self.pre_order_helper(node.right)

# Inorder
def in_order_helper(self, node):
if node != TNULL:
self.in_order_helper(node.left)
sys.stdout.write(node.item + " ")
self.in_order_helper(node.right)

# Postorder
def post_order_helper(self, node):
if node != TNULL:
self.post_order_helper(node.left)
self.post_order_helper(node.right)
sys.stdout.write(node.item + " ")

# Search the tree

def search_tree_helper(self, node, key):
if node == TNULL or key == node.item:
return node

if key < node.item:

return self.search_tree_helper(node.left, key)
return self.search_tree_helper(node.right, key)

# Balancing the tree after deletion

def delete_fix(self, x):
while x != self.root and x.color == 0:
if x == x.parent.left:
s = x.parent.right
if s.color == 1:
s.color = 0
x.parent.color = 1
self.left_rotate(x.parent)
s = x.parent.right

if s.left.color == 0 and s.right.color == 0:

s.color = 1
x = x.parent
else:
if s.right.color == 0:
s.left.color = 0
s.color = 1
self.right_rotate(s)
s = x.parent.right
 s.color = x.parent.color
x.parent.color = 0
s.right.color = 0
self.left_rotate(x.parent)
x = self.root
else:
s = x.parent.left
if s.color == 1:
s.color = 0
x.parent.color = 1
self.right_rotate(x.parent)
s = x.parent.left

if s.right.color == 0 and s.right.color == 0:

s.color = 1
x = x.parent
else:
if s.left.color == 0:
s.right.color = 0
s.color = 1
self.left_rotate(s)
s = x.parent.left

s.color = x.parent.color
x.parent.color = 0
s.left.color = 0
self.right_rotate(x.parent)
x = self.root
x.color = 0

def __rb_transplant(self, u, v):

if u.parent == None:
self.root = v
elif u == u.parent.left:
u.parent.left = v
else:
u.parent.right = v
v.parent = u.parent

# Node deletion
def delete_node_helper(self, node, key):
z = self.TNULL
while node != self.TNULL:
if node.item == key:
z = node

if node.item <= key:

node = node.right
else:
node = node.left
 if z == self.TNULL:
print("Cannot find key in the tree")
return

y=z
y_original_color = y.color
if z.left == self.TNULL:
x = z.right
self.__rb_transplant(z, z.right)
elif (z.right == self.TNULL):
x = z.left
self.__rb_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.__rb_transplant(y, y.right)
y.right = z.right
y.right.parent = y

self.__rb_transplant(z, y)
y.left = z.left
y.left.parent = y
y.color = z.color
if y_original_color == 0:
self.delete_fix(x)

# Balance the tree after insertion

def fix_insert(self, k):
while k.parent.color == 1:
if k.parent == k.parent.parent.right:
u = k.parent.parent.left
if u.color == 1:
u.color = 0
k.parent.color = 0
k.parent.parent.color = 1
k = k.parent.parent
else:
if k == k.parent.left:
k = k.parent
self.right_rotate(k)
k.parent.color = 0
k.parent.parent.color = 1
self.left_rotate(k.parent.parent)
else:
u = k.parent.parent.right
 if u.color == 1:
u.color = 0
k.parent.color = 0
k.parent.parent.color = 1
k = k.parent.parent
else:
if k == k.parent.right:
k = k.parent
self.left_rotate(k)
k.parent.color = 0
k.parent.parent.color = 1
self.right_rotate(k.parent.parent)
if k == self.root:
break
self.root.color = 0

# Printing the tree

def __print_helper(self, node, indent, last):
if node != self.TNULL:
sys.stdout.write(indent)
if last:
sys.stdout.write("R----")
indent += " "
else:
sys.stdout.write("L----")
indent += "| "

s_color = "RED" if node.color == 1 else "BLACK"

print(str(node.item) + "(" + s_color + ")")
self.__print_helper(node.left, indent, False)
self.__print_helper(node.right, indent, True)

def preorder(self):
self.pre_order_helper(self.root)

def inorder(self):
self.in_order_helper(self.root)

def postorder(self):
self.post_order_helper(self.root)

def searchTree(self, k):

return self.search_tree_helper(self.root, k)

def minimum(self, node):

while node.left != self.TNULL:
node = node.left
return node

def maximum(self, node):

while node.right != self.TNULL:
 node = node.right
return node

def successor(self, x):

if x.right != self.TNULL:
return self.minimum(x.right)

y = x.parent
while y != self.TNULL and x == y.right:
x=y
y = y.parent
return y

def predecessor(self, x):

if (x.left != self.TNULL):
return self.maximum(x.left)

y = x.parent
while y != self.TNULL and x == y.left:
x=y
y = y.parent

return y

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 == 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, x):

y = x.left
x.left = y.right
if y.right != self.TNULL:
y.right.parent = x

y.parent = x.parent
if x.parent == None:
self.root = y
elif x == x.parent.right:
x.parent.right = y
 else:
x.parent.left = y
y.right = x
x.parent = y

def insert(self, key):

node = Node(key)
node.parent = None
node.item = key
node.left = self.TNULL
node.right = self.TNULL
node.color = 1

y = None
x = self.root

while x != self.TNULL:
y=x
if node.item < x.item:
x = x.left
else:
x = x.right

node.parent = y
if y == None:
self.root = node
elif node.item < y.item:
y.left = node
else:
y.right = node

if node.parent == None:
node.color = 0
return

if node.parent.parent == None:
return

self.fix_insert(node)

def get_root(self):
return self.root

def delete_node(self, item):

self.delete_node_helper(self.root, item)

def print_tree(self):
self.__print_helper(self.root, "", True)

if __name__ == "__main__":
 bst = RedBlackTree()

bst.insert(55)
bst.insert(40)
bst.insert(65)
bst.insert(60)
bst.insert(75)
bst.insert(57)

bst.print_tree()

print("\nAfter deleting an element")

bst.delete_node(40)
bst.print_tree()

2)Implementation of Fibonacci Heap

Insertion

The Algorithm for Insertion

insert(H, x)

degree[x] = 0

p[x] = NIL

child[x] = NIL

left[x] = x

right[x] = x

mark[x] = FALSE

concatenate the root list containing x with root list H

if min[H] == NIL or key[x] < key[min[H]]

then min[H] = x

n[H] = n[H] + 1

Inserting a node into an already existing heap follows the steps

below:
1. Create a new node for the element.

2. Check if the heap is empty.

3. If the heap is empty, set the new node as a root node and mark it min.
 4. Else, insert the node into the root list and update min.

Union

Union of two fibonacci heaps consists of following steps.

1. Concatenate the roots of both the heaps.

2. Update min by selecting a minimum key from the new root lists.

Extract Min

The following steps are followed:

1. Delete the min node.

2. Set the min-pointer to the next root in the root list.

3. Create an array of size equal to the maximum degree of the trees in the heap before

deletion.

4. Do the following (steps 5-7) until there are no multiple roots with the same degree.

5. Map the degree of current root (min-pointer) to the degree in the array.

6. Map the degree of next root to the degree in array.

7. If there are more than two mappings for the same degree, then apply union operation to

those roots such that the min-heap property is maintained (i.e. the minimum is at the root).

# Fibonacci Heap in python

import math

# Creating fibonacci tree

class FibonacciTree:
def __init__(self, value):
self.value = value
self.child = []
self.order = 0

# Adding tree at the end of the tree

def add_at_end(self, t):
 self.child.append(t)
self.order = self.order + 1

# Creating Fibonacci heap

class FibonacciHeap:
def __init__(self):
self.trees = []
self.least = None
self.count = 0

# Insert a node
def insert_node(self, value):
new_tree = FibonacciTree(value)
self.trees.append(new_tree)
if (self.least is None or value < self.least.value):
self.least = new_tree
self.count = self.count + 1

# Get minimum value

def get_min(self):
if self.least is None:
return None
return self.least.value

# Extract the minimum value

def extract_min(self):
smallest = self.least
if smallest is not None:
for child in smallest.child:
self.trees.append(child)
self.trees.remove(smallest)
if self.trees == []:
self.least = None
else:
self.least = self.trees[0]
self.consolidate()
self.count = self.count - 1
return smallest.value

# Consolidate the tree

def consolidate(self):
aux = (floor_log(self.count) + 1) * [None]

while self.trees != []:

x = self.trees[0]
order = x.order
self.trees.remove(x)
while aux[order] is not None:
y = aux[order]
if x.value > y.value:
 x, y = y, x
x.add_at_end(y)
aux[order] = None
order = order + 1
aux[order] = x

self.least = None
for k in aux:
if k is not None:
self.trees.append(k)
if (self.least is None
or k.value < self.least.value):
self.least = k

def floor_log(x):
return math.frexp(x)[1] - 1

fibonacci_heap = FibonacciHeap()

fibonacci_heap.insert_node(7)
fibonacci_heap.insert_node(3)
fibonacci_heap.insert_node(17)
fibonacci_heap.insert_node(24)

print('the minimum value of the fibonacci heap: {}'.format(fibonacci_heap.get_min()))

print('the minimum value removed: {}'.format(fibonacci_heap.extract_min()))

3)Heap Sort

Heap Sort Algorithm for sorting in increasing order: 

1.Build a max heap from the input data. 

2.At this point, the largest item is stored at the root of the heap. Replace it with the last item of the
heap followed by reducing the size of heap by 1. Finally, heapify the root of the tree. 

3.Repeat step 2 while the size of the heap is greater than 1.

# Python program for implementation of heap Sort

  

# To heapify subtree rooted at index i.

# n is size of heap

  

  

def heapify(arr, n, i):

    largest = i  # Initialize largest as root

    l = 2 * i + 1     # left = 2*i + 1

    r = 2 * i + 2     # right = 2*i + 2

  

    # See if left child of root exists and is

    # greater than root

    if l < n and arr[largest] < arr[l]:

        largest = l

  

    # See if right child of root exists and is

    # greater than root

    if r < n and arr[largest] < arr[r]:

        largest = r

  

    # Change root, if needed

    if largest != i:

        arr[i], arr[largest] = arr[largest], arr[i]  # swap

  

        # Heapify the root.

        heapify(arr, n, largest)

  

# The main function to sort an array of given size

  
  

def heapSort(arr):

    n = len(arr)

  

    # Build a maxheap.

    for i in range(n//2 - 1, -1, -1):

        heapify(arr, n, i)

  

    # One by one extract elements

    for i in range(n-1, 0, -1):

        arr[i], arr[0] = arr[0], arr[i]  # swap

        heapify(arr, i, 0)

  

  

# Driver code

arr = [12, 11, 13, 5, 6, 7]

heapSort(arr)

n = len(arr)

print("Sorted array is")

for i in range(n):

    print("%d" % arr[i],end=" ")