OASYS INSTITUTE OF TECHNOLOGY

Thuraiyur Main Road, Musiri TK ,

Pulivalam, Trichy – 621 006.

Department
of
Information technology
Practical Record Note

Name : ……………………………………………….............

Register No : ……………………………………….........................

Subject : CD3281 Data structures and algorithms Laboratory

Year / Sem : II / III

 OASYS INSTITUTE OF TECHNOLOGY
Thuraiyur Main Road, Musuri TK,
Pulivalam, Trichy – 621 006.

BONAFIDE CERTIFICATE

Certified that this is a Bonafide record of work done by

Mr/Mrs ……………………….……… Reg.No:…......…………………… of II Year /

Third Semester in CD3281 Data structures and algorithms Laboratory during

the academic year 2024– 2025.

Staff In-charge: Head of the

Department
Date: Date:
 TABLE OF CONTENT

EX NO DATE PARTICULARIES PAGE NO MARKS SIGNATURE

1 TO IMPLEMENT SIMPLE ADTS

AS PYTHON CLASSES
2 RECURSIVE ALGORITHM

3 LIST ADTS PYTHON ARRAY

4 LINKED LIST IMPLEMENTATION

OF LIST
5 IMPLEMENTATION OF STACK
AND QUEUE ADTS
6A APPLICATION OF LISTS

6B APPLICATION OF STACK

6C APPLICATION OF QUEUE

7A LINEAR SEARCH

7B BINARY SEARCH

7C SELECTION SORT

7D INSERTION SORT

8 IMPLEMENTATION OF HASH
TABLES
9A TREE REPRESENTION

9B TREE TRAVERSAL ALGORITHM

10 IMPLEMENTATION OF BINARY
SEARCH TREE
11 IMPLEMENTATION OF HEAPS
12A GRAPH REPRESENTION

12 B GRAPH TRAVERSAL
ALGORITHM

13 IMPLEMENTATION OF SINGLE
SOURCE SHORTEST PATH
ALGORITHM
14 IMPLEMENTATION OF
MINIMUM SPANNING TREES
ALGORITHM
Ex.No:1 IMPLEMENT SIMPLE ADTS AS PYTHON CLASSES
DATE :

AIM:

To Implement simple ADTs as Python classes using Stack,Queue,List using python

ALGORITHM:

1.Create a Stack[ ],Queue[],List[] with MAX size as your wish.

2.Write function for all the basic operations of stack,Queue,List - PUSH(), POP() and
DISPLAY(),append(),Extend().

3.Close the program# Stack

PROGRAM:

stack = []

stack.append('a')

stack.append('b')

stack.append('c')

print('Initial stack:')

print(stack)

print('\nElements popped from stack:')

print(stack.pop())

print(stack.pop())

print(stack.pop())

print('\nStack after elements are popped:')

print(stack)

# Queue

queue = []

queue.append('a')

queue.append('b')

queue.append('c')

print('\nInitial queue:')

print(queue)

print('\nElements dequeued from queue:')

print(queue.pop(0))

print(queue.pop(0))

print(queue.pop(0))

print('\nQueue after removing elements:')

print(queue)

# List

List = [1, 2, 3, 4]

print('\nInitial List:')

print(List)

List.extend([8, 'Geeks', 'Always'])

print('\nList after performing Extend Operation:')

OUTPUT:

Stack:

Initial stack

['a', 'b', 'c']

Elements poped from stack:

Stack after elements arepoped:

[]

Queue:

['a', 'b', 'c']

Elements dequeued from queue

Queue after removing elements

[]

List:

Initial List:

[1, 2, 3, 4]

List after performing Extend Operation:

[1, 2, 3, 4, 8, 'Geeks', 'Always]

RESULT: Thus the Implementation of simple ADTs as Python classes was executed successful
EX.NO:2 RECURSIVE ALGORITHM

DATE :

AIM:

To Implement a recursive algorithms in Python using Fibonacci Series

ALGORITHM:

Step 1:Input the 'n' value until which the Fibonacci series has to be generated.

Step 2:Initialize sum = 0, a = 0, b = 1 and count = 1

Step 3:while (count <= n)

Step 4:print sum

Step 5:Increment the count variable

Step 6:swap a and b

Step 7:sum = a + b

Step 8:while (count > n)

Step 9:End the algorithm

Step 10:Else

Step 11:Repeat from steps 4 to 7

PROGRAM:

No = 10

num1, num2 = 0, 1

count = 0

if No<= 0:

print("Invalid Number")

elif No == 1:

print("Fibonacci sequence for limit of", No, ":")

print(num1)

else:

print("Fibonacci sequence:")

while count < No:

print(num1)

nth = num1 + num2

num1 = num2

num2 = nth

count += 1
OUTPUT:

Fibonacci sequence:

13

21

34
RESULT:

Thus the Implementation of recursive algorithms in Python using Fibonacci series was executed
successful
EX.NO:3 LIST ADT USING PYTHON ARRAYS

DATE :

AIM:

To Implement List ADT using Python arrays

ALGORITHM:

1.Using define function intialise the list

2.while loop to declare the elements until the condition is satisfied.

3.using convertarr function to convert the elemnts to an array

4.Stop the program

PROGRAM:

class Node:

def __init__(self, data):

self.data = data

self.next = None

def add(data):

nn = Node(data)

return nn

def print_array(a, n):

i=0

while i< n:

print(a[i], end=" ")

i += 1

print() # To ensure the next line starts after the array is printed

def find_length(head):

cur = head

count = 0

while cur is not None:

count += 1

cur = cur.next

return count

def convert_arr(head):

length = find_length(head)
arr = []

current = head

while current is not None:

arr.append(current.data)

current = current.next

return arr

# Example usage:

# Create nodes and link them

head = Node(6)

head.next = add(4)

head.next.next = add(3)

head.next.next.next = add(4)

# Print the linked list as array

array = convert_arr(head)

print("Linked list converted to array:")

print_array(array, len(array))
Output:

[6,4,3,4]

[6 4 3 4)
RESULT:

Thus the implementation of List in arrays was execute

Ex.NO:4 LINKED LIST IMPLEMENTATIONS OF LIST

DATE :

AIM:

To Implement the Linked list implementations of List using python.

ALGORITHM:

Step 1:Create a list[ ] with MAX size as your wish.

Step 2:Write function for all the basic operations of list - create(), insert(), deletion(),

display().

Step 3:Using append() to extend the elements, removal() to delete the elements

Step 4:Close the program

PROGRAM:

# Initial List

List = [1, 2, 3, 4]

print("Initial List:")

print(List)

# Extend Operation

List.extend([8, 'Geeks', 'Always'])

print("\nList after performing Extend Operation:")

print(List)

# Blank List

List = []

print("\nBlank List:")

print(List)

# List of numbers

List = [10, 20, 14]

print("\nList of numbers:")

print(List)

# List Items

List = ["Geeks", "For", "Geeks"]

print("\nList Items:")

print(List[0])

print(List[2])

# Adding the elements

List = [1, 2, 3, 4]

print("\nInitial List:")

print(List)
List.insert(3, 12)

List.insert(0, 'Geeks')

print("\nList after performing Insert Operation:")

print(List)

# Initial List

List = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print("\nInitial List:")

print(List)

# Removal of elements

List.remove(5)

List.remove(6)

print("\nList after Removal of two elements:")

print(List)

for i in range(1, 5):

List.remove(i)

print("\nList after Removing a range of elements:")

print(List)

# Multi-Dimensional List

List = [['Geeks', 'For'], ['Geeks']]

print("\nMulti-Dimensional List:")

print(List)
OUTPUT:

Initial blank List:

[]

List after Addition of Three elements:

[1, 2, 4]

List after Addition of elements from 1-3:

[1, 2, 4, 1, 2, 3]

>>>

===================== RESTART: Z:/New folder/queue 1.py

=====================

Initial List:

[1, 2, 3, 4]

List after performing Insert Operation:

['Geeks', 1, 2, 3, 12, 4]

>>>

===================== RESTART: Z:/New folder/queue 1.py

=====================

Intial List:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

List after Removal of two elements:

[1, 2, 3, 4, 7, 8, 9, 10, 11, 12]

List after Removing a range of elements:

(7, 8, 9, 10, 11, 12)

RESULT:

Thus the list was created, inserted, removed and extend the element was executed successfully.
EX.NO:5 IMPLEMENTATION OF STACK AND QUEUE ADTS

DATE :

AIM:

To Implement of Stack and Queue ADTs in python.

ALGORITHM:

Step 1: Create a Stack[ ],Queue[] with MAX size as your wish.

Step 2:Write function for all the basic operations of stack - append(),POP()

Step 3: Close the program.

PROGRAM :

# Stack

stack = []

stack.append('a')

stack.append('b')

stack.append('c')

print('Initial stack:')

print(stack)

print('\nElements popped from stack:')

print(stack.pop())

print(stack.pop())

print(stack.pop())

print('\nStack after elements are popped:')

print(stack)

# Queue

queue = []

queue.append('a')

queue.append('b')

queue.append('c')

print('\nInitial queue:')

print(queue)

print('\nElements dequeued from queue:')

print(queue.pop(0))

print(queue.pop(0))

print(queue.pop(0)
('\nQueue after removing elements:')

print(queue)
Output:

Initial stack

['a', 'b', 'c']

Elements poped from stack:

Stack after elements arepoped:

[]
Result:

Thus the program was executed successfully.

EX.NO: 6A APPLICATION OF LIST

DATE :

AIM:

To implement list application using Polynomial Addition in python.

ALGORITHM:

Step 1: Using the define function intial elements will be

declared.

Step 2: for loop gives the output of sum of the elements

Step 3: print[poly] statement have the sum of two polynomial

elements.

Step 4: Close the program.

PROGRAM :

def add(A, B, m, n):

size = max(m, n)

sum = [0 for i in range(size)]

for i in range(0, m):

sum[i] = A[i]

for i in range(n):

sum[i] += B[i]

return sum

def printPoly(poly, n):

for i in range(n):

print(poly[i], end="")

if i != 0:

print("x^", i, end="")

if i != n - 1:

print(" + ", end="")

print() # To ensure the next line starts after the polynomial is printed

if __name__ == '__main__':

A = [5, 0, 10, 6]

B = [1, 2, 4]

m = len(A)

n = len(B)

print("First polynomial is")

printPoly(A, m)
print("Second polynomial is")

printPoly(B, n)

sum = add(A, B, m, n)

size = max(m, n)

print("Sum polynomial is")

printPoly(sum, size)
OUTPUT:

6 + 2x^1 + 14x^2 + 6x^3

First polynomial is

5 + 0x^1 + 10x^2 + 6x^3

Second polynomial is

1 + 2x^1 + 4x^2

Sum polynomial is

6 + 2x^1 + 14x^2 + 6x
RESULT :

Thus the program was executed successfully

EX.NO:5 IMPLEMENTATION OF STACK AND QUEUE ADTS

DATE

AIM: To Implement of Stack and Queue ADTs in python.

ALGORITHM:

Step 1: Create a Stack[ ],Queue[] with MAX size as your wish.

Step 2:Write function for all the basic operations of stack - append(), POP()

Step 3: Close the program

PROGRAM:

Stack implementation

stack = []

stack.append('a')

stack.append('b')

stack.append('c')

print('Initial stack')

print(stack)

print('\nElements popped from stack:')

print(stack.pop())

print(stack.pop())

print(stack.pop())

print('\nStack after elements are popped:')

print(stack)

# Queue implementation

queue = []

queue.append('a')

queue.append('b')

queue.append('c')

print("Initial queue")

print(queue)

print("\nElements dequeued from queue")

print(queue.pop(0))

print(queue.pop(0))

print(queue.pop(0))

print("\nQueue after removing elements")

print(queue)
Output:

Initial stack ['a', 'b', 'c'

Elements poped from stack: c b a Stack after elements are popeD

Result:

Thus the program was executed successfully

EX.NO:6B APPLICATION OF STACK

DATE

AIM: To implement the conversion of infix to postfix in stack.

ALGORITHM:

Step 1: Read the given expression

Step 2: check if empty or not ,the stack will insert the elements.

Step 3: Using push(),pop() to insert the element or remove the element.

Step 4: Check the operator based on the precedence the expression will be evaluated

. Step 5: Close the program

PROGRAM:

class Conversion:

def _init_(self, capacity):

self.top = -1

self.capacity = capacity

self.array = []

self.output = []

self.precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}

def isEmpty(self):

return self.top == -1

def peek(self):

return self.array[-1]

def pop(self):

if not self.isEmpty():

self.top -= 1

return self.array.pop()

else:

return "$"

def push(self, op):

self.top += 1

self.array.append(op)

def isOperand(self, ch):

return ch.isalpha()

def notGreater(self, i):

try:
 a = self.precedence[i]

b = self.precedence[self.peek()]

return True if a <= b else False

except KeyError:

return False

def infixToPostfix(self, exp):

for i in exp:

if self.isOperand(i):

self.output.append(i)

elif i == '(':

self.push(i)

elif i == ')':

while (not self.isEmpty()) and self.peek() != '(':

a = self.pop()

self.output.append(a)

if (not self.isEmpty() and self.peek() != '('):

return -1

else:

self.pop()

else:

while (not self.isEmpty() and self.notGreater(i)):

self.output.append(self.pop())

self.push(i)
 while not self.isEmpty():

self.output.append(self.pop())

print("".join(self.output))

exp = "a+b*(c^d-e)^(f+g*h)-i"

obj = Conversion(len(exp))

obj.infixToPo
OUTPUT: abcd^e-fgh*+^*+i

RESULT: Thus the conversion can be successfully executed

Ex.No:6c APPLICATION OF QUEUE

AIM: To implement the application of queue using FCFS CPU Scheduling.

DATE

ALGORITHM:

1. Input the number of processes required to be scheduled using FCFS, burst time for each process and its
arrival time.

2. Calculate the Finish Time, Turn Around Time and Waiting Time for each process which in turn help to
calculate Average Waiting Time and Average Turn Around Time required by CPU to schedule given set
of process using FCFS.

a. for i = 0, Finish Time T 0 = Arrival Time T 0 + Burst Time T 0

b. for i >= 1, Finish Time T i = Burst Time T i + Finish Time T i – 1

c. for i = 0, Turn Around Time T 0 = Finish Time T 0 - Arrival Time T 0

d. for i >= 1, Turn Around Time T i = Finish Time T i - Arrival Time T i

e. for i = 0, Waiting Time T 0 = Turn Around Time T 0 - Burst Time T 0

f. for i >= 1, Waiting Time T i = Turn Around Time T i - Burst Time T i – 1

3. Process with less arrival time comes first and gets scheduled first by the CPU

. 4. Calculate the Average Waiting Time and Average Turn Around Time

. 5. Stop the program

PROGRAM

def findWaitingTime(processes, n, bt, wt):

wt[0] = 0

for i in range(1, n):

wt[i] = bt[i - 1] + wt[i - 1]

def findTurnAroundTime(processes, n, bt, wt, tat):

for i in range(n):

tat[i] = bt[i] + wt[i]

def findavgTime(processes, n, bt):

wt = [0] * n

tat = [0] * n

total_wt = 0

total_tat = 0

findWaitingTime(processes, n, bt, wt)

findTurnAroundTime(processes, n, bt, wt, tat)

print("Processes Burst time Waiting time Turn around time")

for i in range(n):

total_wt += wt[i]

total_tat += tat[i]

print(f" {i + 1}\t\t{bt[i]}\t {wt[i]}\t\t {tat[i]}")

print(f"Average waiting time = {total_wt / n}")

print(f"Average turn around time = {total_tat / n}")

if _name_ == "_main_"

processes = [1, 2, 3]

n = len(processes)

burst_time = [10, 5, 8]
findavgTime(processes, n, burst_time
Output:

Processes Burst time Waiting time Turn around time

1 10 0 10

2 5 10 15

3 8 15 23

Average waiting time = 8.33333

Average turn around time

RESULT: Thus the FCFS CPU Scheduling was Executed Successfully
EX.NO:7A LINEAR SEARCH

DATE

AIM: To implement the linear search program using python.

ALGORITHM:

Step 1: Start

Step 2: Call Sequential _Search() with list of arguments

Step 3: Assign pos=0

Step 4: Assign found=False

Step 5: Repeat step 5 to 7 until pos

PROGRAM:

list_of_elements = [4, 3, 8, 9, 2, 7] x=int (input ("Enter no to

search :")) found = False

for i in range (len(list_of_elements)): if (list_of_elements[i] ==

x):

found = True

print ("%d found at %dth position"%( x,i)) break

if (found == False):

print ("%d is not in list"%x)

OUTPUT: Enter no to search:4

4 found at 0th position

RESULT:

Thus the python program for the implementation of linear search was executed and the output was
obtained.
Ex.No:7B BINARY SEARCH

DATE

AIM: To implement the binary search program using python.

ALGORITHM: STEP 1: Start

STEP 2: Call binary_search() with list of arguments.

STEP 3: Assign first=0

. STEP 4: Calculate last = len(item_list)-1

STEP 5: Assign found =False

STEP 6: Repeat step 7 to 12 until first <=last and not to found occur false.

STEP 7: Calculate mid = (first + last)/ / 2

STEP 8: Check if item_list[mid]==item then go to step 9 otherwise go to step 10.

STEP 9: Assign found=True

STEP 10: Check if then < item_list[mid]then go to step 11 otherwise go to step 12

. STEP 11: Calculate last=mid – 1

STEP 12: Calculate first=mid + 1

STEP 13: Repeat found to binary_search() and print the value.

STEP 14: Repeat the step 2 to 13 for binary_search()

STEP 15: Repeat the step 2 to 13 for binary_search()

STEP 16: Stop

PROGRAM:

def binary_search(item_list, item):

first = 0

last = len(item_list) - 1

found = False

while first <= last and not found:

mid = (first + last) // 2

if item_list[mid] == item:

found = True

else:

if item < item_list[mid]:

last = mid - 1

else:

first = mid + 1

return foundprint

(binary_search([1, 82, 3, 5, 8], 9))

print(binary_search([1, 2, 3, 5, 8], 5))

OUTPUT: False
RESULT:

Thus the python program for the implementation of binary search was executed and output was obtained.
EX.NO:7C SELECTION SORT

DATE:

AIM: To sort the list of elements using selection sort.

ALGORITHM:

STEP 1: Start

STEP 2: Call selection sort() with list of arguments.

STEP 3: Repeat step 4 to step 5 until range occur false.

STEP 4: Check nlist[location]>nlist[maxpos] then go to step 5 otherwise go to step 6.

STEP 5: Assign maxpos = location

STEP 6: Assign temp = nlist[fillslot]

STEP 7: Assign nlist[fillslot]=nlist[maxpos]

STEP 8: Assign nlist[maxpos]=temp

STEP 9: Return and print the sorted numbers.

PROGRAM:

def selectionSort(alist):

for fillslot in range(len(alist)-1, 0, -1):

positionOfMax = 0

for location in range(1, fillslot+1):

if alist[location] > alist[positionOfMax]:

positionOfMax = location

temp = alist[fillslot]

alist[fillslot] = alist[positionOfMax]

alist[positionOfMax] = temp

alist = [45, 62, 13, 71, 77, 31, 49, 53, 20]

selectionSort(alist)

print(alist)
OUTPUT

13,20,31,45,49,53,62,71,77
RESULT :

Thus the python program for the implementation of selection sort was executed and the output was
obtained.
EX.NO:7D INSERTION SORT

DATE:

AIM: To sort list of elements using Insertion sort

ALGORITHM: STEP 1: Start

STEP 2: Call insertion Sort() with list of arguments.

STEP 3: Repeat the step 4 to step 8 until range occur false

STEP 4: Assign current value = alist[index]

STEP 5:Assign position = index

STEP 6: Repeat the step 7 to step 8 until position >0 and alist[position1]>current value occur false.

STEP 7: Assign alist[position]=alist[position-1]

STEP 8: Calculate position = position – 1

. STEP 9: Assign alist[position]=current value

STEP 10: Print the sorted values.

PROGRAM:

def insertionSort(alist):

for index in range(1, len(alist)):

currentvalue = alist[index]

position = index

while position > 0 and alist[position - 1] > currentvalue:

alist[position] = alist[position - 1]

position = position - 1

alist[position] = currentvalue

alist = [15, 22, 39, 41, 67, 73, 85, 86, 90]

insertionSort(alist)

print(alist)
OUTPUT: 15,22,39,41,67,73,58,56,90
RESULT: Thus the python program for the implementation of insertion sort was executed and output was
obtained.
EX.NO:8 IMPLEMENTATION OF HASH TABLES

DATE:

AIM: To Implement the Hash tables using python

ALGORITHM:

1.Create a structure, data (hash table item) with key and value as data.

2.for loops to define the range within the set of elements.

3.hashfunction(key) for the size of capacity

4.Using insert(),removal() data to be presented or removed

. 5. Stop the program

PROGRAM:

HashTable = [[] for _ in range(10)]

def checkPrime(n):

if n <= 1:

return False

for i in range(2, n // 2 + 1)

if n % i == 0:

return False

return True

def getPrime(n):

if n % 2 == 0:

n += 1

while not checkPrime(n):

n += 2

return n

def hashFunction(key):

capacity = getPrime(10)

return key % capacity

def insertData(key, data):

index = hashFunction(key)

hashTable[index] = [key, data]

def removeData(key):

index = hashFunction(key)

hashTable[index] = []

insertData(123, "apple")

insertData(432, "mango")
insertData(213, "banana")

insertData(654, "guava")

print(hashTable)

removeData(123)

print(hashTable)
OUTPUT: [[], [], [123, 'apple'], [432, 'mango'], [213, 'banana'], [654, 'guava'], [], [], [], []] [[], [], 0, [432,
'mango'], [213, 'banana'], [654, 'guava'], [], [], [], []]
RESULT: Thus the Implementation of hashing was executed successful
Ex.No:9a Tree representation

DATE

Aim: To implement tree representation in binary tree format

ALGORITHM:

1.Create a binary tree.

2.Intially all the left and right vertex are none , then declare the values using insert()

function. 3.If data>right element place the element in right

4.If data<left element place the element in left

5.print the tree

6.Stop the program

PROGRAM:

class Node:

def _init_(self, data): # Corrected the constructor method name

self.left = None

self.right = None

self.data = data

def insert(self, data):

if self.data:

if data < self.data:

if self.left is None:

self.left = Node(data)

else:

self.left.insert(data)

elif data > self.data:

if self.right is None:

self.right = Node(data)

else:

self.right.insert(data)

else:

self.data = data

def PrintTree(self):

if self.left:

self.left.PrintTree()

print(self.data, end=' ') # Corrected the print statement

if self.right

self.right.PrintTree()
# Example usage

root = Node(12)

root.insert(6)

root.insert(14)

root.insert(3)

root.PrintTree()
Output: 3 6 12 14
Result: Thus the binary tree was successfully created
Ex.No:9b Tree Traversal Algorithms

DATE:

Aim: To Implement traversal using Inorder,Preorder,Postorder techniques

Algorithm:

1. Traverse the left subtree, i.e., call Inorder(left-subtree)

2. Visit the root

. 3. Traverse the right subtree, i.e., call Inorder(right-subtree) Preorder(tree)

1. Visit the root.

2. Traverse the left subtree, i.e., call Preorder(left-subtree)

3. Traverse the right subtree, i.e., call Preorder(right-subtree)

Postorder(tree)

1. Traverse the left subtree, i.e., call Postorder(left-subtree)

2. Traverse the right subtree, i.e., call Postorder(right-subtree)

CODEING:

class Node:

def _init_(self, key):

self.left = None

self.right = None

self.val = key

def printInorder(root):

if root:

printInorder(root.left)

print(root.val, end=' ')

printInorder(root.right)

def printPostorder(root):

if root:

printPostorder(root.left)

printPostorder(root.right)

print(root.val, end=' ')

def printPreorder(root):

if root:

print(root.val, end=' ')

printPreorder(root.left)

printPreorder(root.right)

# Creating the tree

root = Node(1)

root.left = Node(2)

root.right = Node(3)

root.left.left = Node(4)
root.left.right = Node(5)

# Printing the traversals

print("Preorder traversal of binary tree is")

printPreorder(root)

print("\nInorder traversal of binary tree is")

printInorder(root)

print("\nPostorder traversal of binary tree is")

printPostorder(root)
Ex.No: 10 Implementation of Binary Search Trees

DATE:

Aim:

To Implement the Binary Search Trees using python

Algorithm:

Step 1-Read the search element from the user.

Step 2 - Compare the search element with the value of root node in the tree.

Step 3 - If both are matched, then display "Given node is found!!!" and terminate the function

Step 4 - If both are not matched, then check whether search element is smaller or larger than that node
value

Step 5 - If search element is smaller, then continue the search process in left subtree.

Step 6- If search element is larger, then continue the search process in right subtree.

Step 7 - Repeat the same until we find the exact element or until the search element is compared with leaf
node

Step 8 - If we reach to the node having the value equal to the search value then display "Elementis found"
and terminate the function.
PROGRAM :

class Node:

def __init__(self, data):

self.left = None

self.right = None

self.data = data

def insert(self, data):

if self.data:

if data <self.data:

if self.left is None:

self.left = Node(data)

else:

self.left.insert(data)

elif data >self.data:

if self.right is None:

self.right = Node(data)

else:

self.right.insert(data)

else:

self.data = data

def findval(self, lkpval):

if lkpval<self.data:

if self.left is None:

return str(lkpval) + " Not Found"

return self.left.findval(lkpval)

eliflkpval>self.data
 if self.right is None:

return str(lkpval) + " Not Found"

return self.right.findval(lkpval)

else:

return str(self.data) + " is found"

def PrintTree(self):

if self.left:

self.left.PrintTree()

print(self.data, end=" ")

if self.right:

self.right.PrintTree()

# Example usage:

root = Node(12)

root.insert(6)

root.insert(14)

root.insert(3)

print(root.findval(7))

root.PrintTree()
Output:

7 Not Found

14 is found
RESULT :

Thus the Implementation of Binary Search Trees using python was executed successful
Ex.NO:11 Implementation of Heaps

DATE :

Aim:

To Implement the Heap algorithm using python

Algorithm:

1.Insert the heap function in the list

2.using heappush(),heappop(),heapify() to insert ,delete,display the elements.

3.Stop the program

Coding:

import heapq

H = [21,1,45,78,3,5]

heapq.heapify(H)

print(H)

heapq.heappush(H,8)

print(H)

heapq.heappop(H)

print(H)
Output:

1, 3, 5, 78, 21, 45

[1, 3, 5, 78, 21, 45, 8]

[3, 8, 5, 78, 21, 45]

RESULT :

Thus the Implementation of the Heap algorithm was executed successfully

Ex.No:12a Graph representation

DATE :

Aim:

To implement the graph representation using python

ALGORITHM :

1. Initialize a 2D array adj_matrix of size VxV with all elements set to 0.

2. For each edge (u, v) in the graph:

Set adj_matrix[u][v] = 1.

If the graph is undirected, also set adj_matrix[v][u] = 1.

3. Initialize an array adj_list of size V, where each element is an empty list.

4.For each edge (u, v) in the graph:

Append v to the list at adj_list[u].

If the graph is undirected, also append u to the list at adj_list[v].

5. Initialize an empty list edge_list.

6. For each edge (u, v) in the graph:

Append the pair (u, v) to edge_list.

PROGRAM :

class Graph:

def __init__(self, gdict=None):

if gdict is None:

gdict = {}

self.gdict = gdict

def getVertices(self):

return list(self.gdict.keys())

def edges(self):

return self.findedges()

def findedges(self):

edgename = []

for vrtx in self.gdict:

for nxtvrtx in self.gdict[vrtx]:

if {nxtvrtx, vrtx} not in edgename:

edgename.append({vrtx, nxtvrtx})

return edgename

# Example usage

graph_elements = {

"a": ["b", "c"],

"b": ["a", "d"],

"c": ["a", "d"],

"d": ["e"],

"e": ["d"]

}
g = Graph(graph_elements)

print("Vertices of graph:")

print(g.getVertices())

print("Edges of graph:")

print(g.edges())
Output:

DISPLAYING VERTICES

['a', 'b', 'c', 'd', 'e']

DISPLAYING EDGES

[{'a', 'b'}, {'a', 'c'}, {'d', 'b'}, {'c', 'd'}, {'d', 'e}
RESULT :

Thus the implementation of graphs was executed successfully

Ex.No:12b Graph Traversal Algorithms

DATE:

Aim:

To Implement using BFS,DFS can be traversed.

Algorithm:

DFS:

Step 1 - Define a Stack of size total number of vertices in the graph.

Step 2 - Select any vertex as starting point for traversal. Visit that vertex and push it on to the stack.

Step 3 - Visit any one of the non-visited adjacent vertices of a vertex which is at the top of stack and push
it on the stack.

Step 4 - Repeat step 3 until there is no new vertex to be visited from the vertex which is at thetop of the
stack.

Step 5 - When there is no new vertex to visit then use back tracking and pop one vertex from thestack.

Step 6 - Repeat steps 3, 4 and 5 until stack becomes Empty.

Step 7 - When stack becomes Empty, then produce final spanning tree by removing unused edgefrom the
graph

BFS:

Step 1 - Define a Queue of size total number of vertices in the graph.

Step 2 - Select any vertex as starting point for traversal. Visit that vertex and insert it into theQueue.

Step 3 - Visit all the non-visited adjacent vertices of the vertex which is at front of the Queue andinsert
them into the Queue.

Step 4 - When there is no new vertex to be visited from the vertex which is at front of the Queuethen
delete that vertex.

Step 5 - Repeat steps 3 and 4 until queue becomes empty.

Step 6 - When queue becomes empty, then produce final spanning tree by removing unused edgesfrom
the graph
BFS PROGRAM :

import collections

def bfs(graph, root):

visited, queue = set(), collections.deque([root])

visited.add(root)

while queue:

vertex = queue.popleft()

print(str(vertex) + " ", end="")

for neighbour in graph[vertex]:

if neighbour not in visited:

visited.add(neighbour)

queue.append(neighbour)

if __name__ == '__main__':

graph = {0: [1, 2], 1: [2], 2: [3], 3: [1, 2]}

print("Following is Breadth First Traversal:")

bfs(graph, 0)
Output:

Following is Breadth First Traversal:

012
DFS PROGRAM :

import sys

def ret_graph():

return {

'A': {'B': 5.5, 'C': 2, 'D': 6},

'B': {'A': 5.5, 'E': 3},

'C': {'A': 2, 'F': 2.5},

'D': {'A': 6, 'F': 1.5},

'E': {'B': 3, 'J': 7},

'F': {'C': 2.5, 'D': 1.5, 'K': 1.5, 'G': 3.5},

'G': {'F': 3.5, 'I': 4},

'H': {'J': 2},

'I': {'G': 4, 'J': 4},

'J': {'H': 2, 'I': 4},

'K': {'F': 1.5}

start = 'A'

dest = 'J'

visited = []

stack = []

graph = ret_graph()

path = []

stack.append(start)

visited.append(start)
while stack:

curr = stack.pop()

path.append(curr)

for neigh in graph[curr]:

if neigh not in visited:

visited.append(neigh)

stack.append(neigh)

if neigh == dest:

print("FOUND:", neigh)

print(path)

sys.exit(0)

print("Not found")

print(path)
Output:

FOUND: J

['A', 'D', 'F', 'G', 'I')

RESULT :

Thus the implementation of using BFS,DFS graph can be traversed

Ex.No:13 Implementation of single source shortest path algorithm

DATE:

Aim:

To Implement single source shortest path algorithm using Bellman Ford Algorithm

Algorithm:

1) This step initializes distances from source to all vertices as infinite and distance to source itself as 0.
Create an array dist[] of size |V| with all values as infinite except dist[src] where src is source vertex.

2) This step calculates shortest distances. Do following |V|-1 times where |V| is the number ofvertices in
given graph.

3)Do following for each edge u-vIf dist[v] >dist[u] + weight of edge uv, then update dist[v]dist[v] =
dist[u] + weight of edge uv

4) This step reports if there is a negative weight cycle in graph. Do following for each edge u-vIf
dist[v] >dist[u] + weight of edge uv, then “Graph contains negative weight cycle”The idea of step 3 is,
step 2 guarantees shortest distances if graph doesn’t contain negative weight cycle. If we iterate through
all edges one more time and get a shorter path for any vertex,then there is a negative weight cycle
PROGRAM :

from sys import maxsize

def BellmanFord(graph, V, E, src):

dis = [maxsize] * V

dis[src] = 0

for i in range(V - 1):

for j in range(E):

if dis[graph[j][0]] + graph[j][2] < dis[graph[j][1]]:

dis[graph[j][1]] = dis[graph[j][0]] + graph[j][2]

for i in range(E):

x = graph[i][0]

y = graph[i][1]

weight = graph[i][2]

if dis[x] != maxsize and dis[x] + weight < dis[y]:

print("Graph contains negative weight cycle")

return

print("Vertex Distance from Source")

for i in range(V):

print("%d\t\t%d" % (i, dis[i]))

if __name__ == "__main__":

V = 5 # Number of vertices in graph

E = 8 # Number of edges in graph

graph = [

[0, 1, -1], [0, 2, 4], [1, 2, 3],

[1, 3, 2], [1, 4, 2], [3, 2, 5],

[3, 1, 1], [4, 3, -3]

 ]

BellmanFord(graph, V, E, 0)
Output:

Vertex Distance from Source

00

1 -1

22

3 -2
RESULT :

Thus the Implementation of single source shortest path algorithm was successfully execute
Ex.No:14 Implementation of minimum spanning tree algorithms

DATE:

Aim:

To implement the minimum spanning tree algorithms using Kruskal Algorithm

Algorithm:

1.Label each vertex

2. List the edges in non-decreasing order of weight.

3. Start with the smallest weighted and beginning growing the minimum weighted spanning tree from this
edge.

4. Add the next available edge that does not form a cycle to the construction of the minimum weighted
spanning tree. If the addition of the next least weighted edge forms a cycle, do not use it.

5. Continue with step 4 until you have a spanning tree.

PROGRAM :

class Graph:

def __init__(self, vertices):

self.V = vertices

self.graph = []

def add_edge(self, u, v, w):

self.graph.append([u, v, w])

def find(self, parent, i):

if parent[i] == i:

return i

return self.find(parent, parent[i])

def apply_union(self, parent, rank, x, y):

xroot = self.find(parent, x)

yroot = self.find(parent, y)

if rank[xroot] < rank[yroot]:

parent[xroot] = yroot

elif rank[xroot] > rank[yroot]:

parent[yroot] = xroot

else:

parent[yroot] = xroot

rank[xroot] += 1

def kruskal_algo(self):

result = []

i, e = 0, 0

self.graph = sorted(self.graph, key=lambda item: item[2])

parent = []
 rank = []

for node in range(self.V):

parent.append(node)

rank.append(0)

while e <self.V - 1:

u, v, w = self.graph[i]

i=i+1

x = self.find(parent, u)

y = self.find(parent, v)

if x != y:

e=e+1

result.append([u, v, w])

self.apply_union(parent, rank, x, y)

for u, v, weight in result:

print("%d - %d: %d" % (u, v, weight))

# Example usage

g = Graph(6)

g.add_edge(0, 1, 4)

g.add_edge(0, 2, 4)

g.add_edge(1, 2, 2)

g.add_edge(1, 0, 4)

g.add_edge(2, 0, 4)

g.add_edge(2, 1, 2)

g.add_edge(2, 3, 3)

g.add_edge(2, 5, 2)

g.add_edge(2, 4, 4)
g.add_edge(3, 2, 3)

g.add_edge(3, 4, 3)

g.add_edge(4, 2, 4)

g.add_edge(4, 3, 3)

g.add_edge(5, 2, 2)

g.add_edge(5, 4, 3)

g.kruskal_algo()
Output:

1 - 2: 2

2 - 5: 2

2 - 3: 3

3 - 4: 3
RESULT :

Thus the program was executed successfully