Dsa - Copy-41-133
Dsa - Copy-41-133
Algorithm:
2. Allocate memory to create a newNode with given value and name it as NEW_NODE.
4. If TOP == NULL means empty, then set newNode → next = NULL and TOP =
NEW_NODE.
5. If TOP != NULL, then set newNode → next = top and TOP = NEW_NODE.
Program:
class Node:
def init (self, data=None, next=None):
self.data = data
self.next = next
class Stack:
def init (self):
self.top = None
self.size=0
def push(self, data):
if self.top is None:
self.top = Node(data, None)
self.size += 1
return
self.top = Node(data, self.top)
self.size += 1
def pop(self):
if self.top is None:
return
temp = self.top
if self.top is not None:
self.top = self.top.next
temp.next = None
self.size -= 1
return temp.data
def getSize(self):
return self.size
def peek(self):
return self.top.data
def clearstack(self):
self.top = None
def emptystack(self):
if self.top is None:
return True
return False
def display(self):
itr = self.top
sstr = ' '
while itr:
sstr += str(itr.data) + '-->'
itr = itr.next
print(sstr)
if name == " main ":
stack = Stack()
stack.push(10)
stack.push(20)
stack.push(30)
stack.push(40)
print("List of elements in stack:")
stack.display()
print("The size of the stack is:",stack.getSize())
print("The top of the element is:",stack.peek())
print("The popped element from the stack:" ,stack.pop())
print("The size of the stack is:",stack.getSize())
stack.display()
print(stack.emptystack())
stack.clearstack()
print(stack.emptystack())
Output:
Result:
Ex.No:5b Implementation of Queue Using Linked List
Date:
Aim:
Algorithm:
3. Define two Node pointers 'front' and 'rear' and set both to NULL.
4. Create a newNode with given value and set 'newNode → next' to NULL.
7. If it is Not Empty then, set rear → next = newNode and rear = newNode
9. If it is Empty, then display "Queue is Empty!!! Deletion is not possible!!!" and terminate from the
function
10. If it is Not Empty then, define a Node pointer 'temp' and set it to 'front'.
11. Then set 'front = front → next' and delete 'temp' (free(temp)).
13. If it is Empty then, display 'Queue is Empty!!!' and terminate the function.
14. If it is Not Empty then, define a Node pointer 'temp' and initialize with front.
15. Display 'temp → data --->' and move it to the next node. Repeat the same until 'temp' reaches to 'rear'
(temp → next != NULL).
class Node:
def init (self, data, left=None, right=None):
self.data = data
self.next = None
class Queue:
def init (self):
self.rear = None
self.front = None
self.count = 0
def dequeue(self):
if self.front is None:
print('Queue Underflow')
exit(-1)
temp = self.front
print('Removing…', temp.data)
self.front = self.front.next
if self.front is None:
self.rear = None
self.count -= 1
return temp.data
Output:
Result:
Ex.No:6a Implementation of Polynomial Manipulation Using List
Date:
Aim:
Algorithm:
4. Create a newNode with given value and insert the node, when the list is empty
5. If the list in not empty, compare the new node with the existing node
If the power value of newnode is greater than existing node, then insert the node as head element
Else, if the power value of newnode is smaller than existing node, then insert the node as next
element
If the power value of newnode is equal to existing node, then add the power value of existing node and
new node, insert the node
7. Define a two variable first and second and make the first = self.head , second = other.head
8. Check the power value of two variables, if it is equal, then add the power value and coefficient, then
insert the newnode in equation
10. Create the display method to print the values of both equation
Program:
class Node :
def init (self, data, power) :
self.data = data
self.power = power
self.next = None
def updateRecord(self, data, power) :
self.data = data
self.power = power
class AddPolynomial :
def init (self) :
self.head = None
def display(self) :
if (self.head == None) :
print("Empty Polynomial ")
print(" ", end = "")
temp = self.head
location.next = node
def addTwoPolynomials(self, other) :
result = None
tail = None
node = None
first = self.head
second = other.head
while (first != None or second != None) :
node = Node(0, 0)
if (result == None) :
result = node
if (first != None and second != None) :
if (first.power == second.power) :
node.updateRecord(first.data + second.data, first.power)
first = first.next
second = second.next
elif (first.power > second.power) :
node.updateRecord(first.data, first.power)
first = first.next
else :
node.updateRecord(second.data, second.power)
second = second.next
elif (first != None) :
node.updateRecord(first.data, first.power)
first = first.next
else :
node.updateRecord(second.data, second.power)
second = second.next
if (tail == None) :
tail = node
else :
tail.next = node
tail = node
return result
def main() :
poly1 = AddPolynomial()
poly2 = AddPolynomial()
result = AddPolynomial()
poly1.addNode(9, 3)
poly1.addNode(4, 2)
poly1.addNode(3, 0)
poly1.addNode(7, 1)
poly1.addNode(3, 4)
poly2.addNode(7, 3)
poly2.addNode(4, 0)
poly2.addNode(6, 1)
poly2.addNode(1, 2)
print("Polynomial A")
poly1.display()
print(" Polynomial B")
poly2.display()
result.head = poly1.addTwoPolynomials(poly2)
print(" Result")
result.display()
if name == " main ": main()
Output
Result:
Ex.No:6b Implementation of Infix to Postfix Conversion Using Stack
Date:
Aim:
To write a python program to implement infix to postfix using stack
Algorithm
Step 1 : Scan the Infix Expression from left to right.
Step 2 : If the scanned character is an operand, append it with final Infix to Postfix string.
Step 3 : Else,
Step 3.1 : If the precedence order of the scanned(incoming) operator is greater than
the precedence order of the operator in the stack (or the stack is empty or the stack contains
a ‘(‘ or ‘[‘ or ‘{‘), push it on stack.
Step 3.2 : Else, Pop all the operators from the stack which are greater than or equal
to in precedence than that of the scanned operator. After doing that Push the scanned
operator to the stack. (If you encounter parenthesis while popping then stop there and push
the scanned operator in the stack.)
Step 4 : If the scanned character is an ‘(‘ or ‘[‘ or ‘{‘, push it to the stack.
Step 5 : If the scanned character is an ‘)’or ‘]’ or ‘}’, pop the stack and and output it until a
‘(‘ or ‘[‘ or ‘{‘ respectively is encountered, and discard both the parenthesis.
Step 6 : Repeat steps 2-6 until infix expression is scanned.
Step 7 : Print the output
Step 8 : Pop and output from the stack until it is not empty.
Program:
class infix_to_postfix:
precedence={'^':5,'*':4,'/':4,'+':3,'-':3,'(':2,')':1}
def init (self):
self.items=[]
self.size=-1
def push(self,value):
self.items.append(value)
self.size+=1
def pop(self):
if self.isempty():
return 0
else:
self.size-=1
return self.items.pop()
def isempty(self):
if(self.size==-1):
return True
else:
return False
def seek(self):
if self.isempty():
return false
else:
return self.items[self.size]
def isOperand(self,i):
if i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
return True
else:
return False
def infixtopostfix (self,expr):
postfix=""
print('postfix expression after every iteration is:')
for i in expr:
if(len(expr)%2==0):
print("Incorrect infix expr")
return False
elif(self.isOperand(i)):
postfix +=i
elif(i in '+-*/^'):
while(len(self.items)and self.precedence[i]<=self.precedence[self.seek()]):
postfix+=self.pop()
self.push(i)
elif i is '(':
self.push(i)
elif i is ')':
o=self.pop()
while o!='(':
postfix +=o
o=self.pop()
print(postfix)
#end of for
while len(self.items):
if(self.seek()=='('):
self.pop()
else:
postfix+=self.pop()
return postfix
s=infix_to_postfix()
expr=input('enter the expression ')
result=s.infixtopostfix(expr)
if (result!=False):
print("the postfix expr of :",expr,"is",result)
Output:
Result
Ex.No:6c Implementation of Queue Using Stack
Date:
Aim:
Algorithm:
3. Create the list item[] and insert the insert elements by using stack on queue
Program:
class Queue:
def init (self):
self.inbox = Stack()
self.outbox = Stack()
def is_empty(self):
return (self.inbox.is_empty() and self.outbox.is_empty())
def enqueue(self, data):
self.inbox.push(data)
def dequeue(self):
if self.outbox.is_empty():
while not self.inbox.is_empty():
popped = self.inbox.pop()
self.outbox.push(popped)
return self.outbox.pop()
class Stack:
def init (self):
self.items = []
def is_empty(self):
return self.items == []
def push(self, data):
self.items.append(data)
def pop(self):
return self.items.pop()
a_queue = Queue()
while True:
print('enqueue <value>')
print('dequeue')
print('quit')
do = input('What would you like to do? ').split()
operation = do[0].strip().lower()
if operation == 'enqueue':
a_queue.enqueue(int(do[1]))
elif operation == 'dequeue':
if a_queue.is_empty():
print('Queue is empty.')
else:
dequeued = a_queue.dequeue()
print('Dequeued element: ', int(dequeued))
elif operation == 'quit':
break
Output:
Result
Ex.No:7a Implementation of Bubble Sort Algorithm
Date:
Aim:
Algorithm
Program
def bubbleSort(arr):
n = len(arr)
for i in range(n-1):
arr = list()
for i in range(n):
bubbleSort(arr)
Result:
Ex.No:7b Implementation of Selection Sort
Date: Algorithm
Aim:
Algorithm:
Program:
arr = list()
n=int(input("Enter the Size of the List:"))
for i in range(n):
arr.append(int(input("Enter the element:")))
print ("The array is:",arr)
for i in range(0,n):
j=i+1
for j in range(j, n):
if arr[i] > arr[j]:
arr[i] ,arr[j] =arr[j] ,arr[i]
print ("Sorted array is:",arr)
Output:
Result:
Ex.No:7c Implementation of Insertion Sort Algorithm
Date:
Aim:
Algorithm
Program:
def insertionSort(arr):
for i in range(1, len(arr)):
key = arr[i]
j=i
j = i-1
while j >=0 and key < arr[j] :
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
print(arr)
arr = list()
n=int(input("Enter the Size of the List:"))
for i in range(n):
Result:
Ex.No:7d Implementation of Quick Sort Algorithm
Date:
Aim:
Algorithm:
1. Select the Pivot Element as first, last, random and median element
2. Rearrange the Array
a. A pointer is fixed at the pivot element. The pivot element is compared with the
elements beginning from the first index.
b. If the element is greater than the pivot element, a second pointer is set for that
element.
c. Now, pivot is compared with other elements. If an element smaller than the pivot
element is reached, the smaller element is swapped with the greater element
found earlier.
d. Again, the process is repeated to set the next greater element as the second
pointer. And, swap it with another smaller element.
e. The process goes on until the second last element is reached.
f. Finally, the pivot element is swapped with the second pointer
3. Divide Subarrays
a. Pivot elements are again chosen for the left and the right sub-parts separately.
And, step 2 is repeated.
b. The subarrays are divided until each subarray is formed of a single element. At
this point, the array is sorted.
Program:
import random
def pivot_place(list1,first,last):
rindex = random.randint(first, last)
list1[rindex], list1[last] = list1[last], list1[rindex]
pivot = list1[last]
left = first
right = last-1
while True:
while left <= right and list1[left] <= pivot:
left = left+1
while left <= right and list1[right] >= pivot:
right = right-1
if right < left:
break
else:
list1[left], list1[right] = list1[right], list1[left]
list1[last], list1[left] = list1[left], list1[last]
return left
def quicksort(list1, first, last):
if first < last:
p=pivot_place(list1, first, last)
quicksort(list1, first, p-1)
quicksort(list1, p+1, last)
list1 = list()
n=int(input("Enter the Size of the List:"))
for i in range(n):
list1.append(int(input("Enter the element:")))
print ("The array is:",list1)
quicksort(list1, 0, n-1)
print(list1)
Output:
Result:
Ex.No:7e Implementation of Merge Sort Algorithm
Date:
Aim:
To write a program to implement Merge sort algorithm
Algorithm:
def mergeSort(arr):
if len(arr) > 1:
mid = len(arr)//2
L = arr[:mid]
R = arr[mid:]
mergeSort(L)
mergeSort(R)
i=0
j=0
k=0
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
def printList(arr):
for i in range(len(arr)):
print(arr[i], end=" ")
print()
arr = list()
n=int(input("Enter the Size of the List:"))
for i in range(n):
arr.append(int(input("Enter the element:")))
print ("The array is:",arr)
mergeSort(arr)
print("Sorted array is: ", end="\n")
printList(arr)
Output:
Enter the Size of the List:7
Enter the element:54
Enter the element:5
Enter the element:41
Enter the element:12
Enter the element:17
Enter the element:65
Enter the element:7
The array is: [54, 5, 41, 12, 17, 65, 7]
Sorted array is:
5 7 12 17 41 54 65
Result
Ex.No:7f Implementation of Linear Search Algorithm
Date:
Aim:
Algorithm:
Program:
Output:
Enter the Size of the List:5
Enter the element:45
Enter the element:12
Enter the element:78
Enter the element:65
Enter the element:48
The array is: [45, 12, 78, 65, 48]
Enter the element to be search:12
element exist in position 1
Result:
Ex.No:7g Implementation of Binary Search Algorithm
Date:
Aim:
Algorithm:
Program:
def binary_search(arr, low, high, x):
if arr[mid] == x:
return mid
else:
else:
return -1
arr = list()
n=int(input("Enter the Size of the List:"))
for i in range(n):
if result != -1:
else:
Output:
Result
Ex.No:8a Implementation of Hashing with linear probing
Date:
Aim:
Algorithm:
class hashTable:
self.elementCount = 0
self.comparisons = 0
def isFull(self):
if self.elementCount == self.size:
return True
else:
return False
if self.isFull():
return False
isStored = False
position = self.hashFunction(element)
if self.table[position] == 0:
self.table[position] = element
self.elementCount += 1
else:
print("Collision has occured for element " + str(element) + " at position " +
str(position) + " finding new Position.")
while self.table[position] != 0:
position += 1
position = 0
self.table[position] = element
isStored = True
self.elementCount += 1
return isStored
found = False
position = self.hashFunction(element)
self.comparisons += 1
if(self.table[position] == element):
return position
isFound = True
else:
temp = position - 1
if self.table[position] != element:
position += 1
self.comparisons += 1
else:
return position
position = temp
if self.table[position] != element:
position -= 1
self.comparisons += 1
else:
return position
if not found:
return False
position = self.search(element)
self.table[position] = 0
self.elementCount -= 1
else:
return
def display(self):
print("\n")
for i in range(self.size):
table1 = hashTable()
table1.insert(50)
table1.insert(100)
table1.insert(76)
table1.insert(85)
table1.insert(92)
table1.insert(73)
table1.insert(101)
table1.display()
print()
print()
table1.remove(73)
table1.display()
Output
Element 50 at position 1
Element 76 at position 6
Collision has occured for element 101 at position 3 finding new Position.
0 = 101
1 = 50
2 = 100
3 = 85
4 = 92
5 = 73
6 = 76
Element 73 is Deleted
0 = 101
1 = 50
2 = 100
3 = 85
4 = 92
5=0
6 = 76
Result:
Ex.No:8b Implementation of Hashing with Quadratic Probing
Date:
Aim:
Algorithm:
class hashTable:
self.elementCount = 0
self.comparisons = 0
def isFull(self):
if self.elementCount == self.size:
return True
else:
return False
posFound = False
limit = 50
i=1
if self.table[newPosition] == 0:
posFound = True
break
else:
i += 1
return posFound, newPosition
if self.isFull():
return False
isStored = False
position = self.hashFunction(element)
if self.table[position] == 0:
self.table[position] = element
isStored = True
self.elementCount += 1
else:
print("Collision has occured for element " + str(element) + " at position " +
str(position) + " finding new Position.")
if isStored:
self.table[position] = element
self.elementCount += 1
return isStored
found = False
position = self.hashFunction(element)
self.comparisons += 1
if(self.table[position] == element):
return position
else:
limit = 50
i=1
newPosition = position
self.comparisons += 1
if self.table[newPosition] == element:
found = True
break
elif self.table[newPosition] == 0:
found = False
break
else:
i += 1
if found:
return newPosition
else:
return found
position = self.search(element)
self.table[position] = 0
else:
return
def display(self):
print("\n")
for i in range(self.size):
table1 = hashTable()
table1.insert(50)
table1.insert(100)
table1.insert(76)
table1.insert(85)
table1.insert(92)
table1.insert(73)
table1.insert(101)
table1.display()
print()
str(table1.comparisons))
print()
#table1.remove(90)
table1.remove(73)
table1.display()
Output:
Element 50 at position 1
Element 76 at position 6
Collision has occured for element 85 at position 1 finding new Position.
Collision has occured for element 101 at position 3 finding new Position.
0 = 101
1 = 50
2 = 100
3 = 92
4 = 73
5 = 85
6 = 76
Element 73 is Deleted
0 = 101
1 = 50
2 = 100
3 = 92
4=0
5 = 85
6 = 76
Result:
Ex.No:8c Implementation of Hashing with double hashing
Date:
Aim:
Algorithm:
Program:
class doubleHashTable:
self.elementCount = 0
self.comparisons = 0
def isFull(self):
if self.elementCount == self.size:
return True
else:
return False
posFound = False
limit = 50
i=1
if self.table[newPosition] == 0:
posFound = True
break
else:
i += 1
if self.isFull():
return False
posFound = False
position = self.h1(element)
if self.table[position] == 0:
self.table[position] = element
isStored = True
self.elementCount += 1
else:
print("Collision has occured for element " + str(element) + " at position " +
str(position) + " finding new Position.")
if posFound:
self.table[position] = element
self.elementCount += 1
return posFound
found = False
position = self.h1(element)
self.comparisons += 1
if(self.table[position] == element):
return position
else:
limit = 50
i=1
newPosition = position
self.comparisons += 1
if self.table[position] == element
found = True
break
elif self.table[position] == 0:
found = False
break
else:
i += 1
if found:
return position
else:
return found
position = self.search(element)
self.table[position] = 0
else:
return
def display(self):
print("\n")
for i in range(self.size):
table1 = doubleHashTable()
table1.insert(89)
table1.insert(18)
table1.insert(49)
table1.insert(58)
table1.insert(9)
table1.display()
print()
print()
table1.remove(18)
table1.display()
Output:
0=0
1=0
2=0
3 = 58
4=9
5=0
6 = 49
7=0
8 = 18
9 = 89
The number of element is the Table are : 5
The position of element 9 is : 4
The position of element 58 is : 3
Total number of comaprisons done for searching = 4
Element 18 is Deleted
0=0
1=0
2=0
3 = 58
4=9
5=0
6 = 49
7=0
8=0
9 = 89
The number of element is the Table are : 4
Result:
Ex.No:9 Implementation Of Tree Representation And Traversal Algorithm
Date:
Aim:
Algorithm:
class Node:
self.left = None
self.right = None
self.data = data
if self.data:
if self.left is None:
self.left = Node(data)
else:
self.left.insert(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),
if self.right:
self.right.PrintTree()
res = []
if root:
res = self.inorderTraversal(root.left)
res.append(root.data)
return res
res = []
if root:
res.append(root.data)
return res
if root:
res = self.PostorderTraversal(root.left)
return res
root = Node(27)
root.insert(14)
root.insert(35)
root.insert(10)
root.insert(19)
root.insert(31)
root.insert(42)
print(root.inorderTraversal(root))
print(root.PreorderTraversal(root))
print(root.PostorderTraversal(root))
Output
Result
Ex.No:10a Implementation Of Binary Search Tree
Date:
Aim:
Algorithm:
1. Insert node into the tree as the root of the tree.
2. Read the next element, if it is lesser than the root node element, insert it as the root of
the left sub-tree.
3. Otherwise, insert it as the root of the right of the right sub-tree
4. Compare the element with the root of the tree.
5. If the item is matched then return the location of the node.
6. Otherwise check if item is less than the element present on root, if so then move to
the left sub-tree.
7. If not, then move to the right sub-tree.
8. Repeat this procedure recursively until match found.
9. If element is not found then return NULL.
10. Find the data of the node to be deleted.
11. If the node is a leaf node, delete the node directly.
12. Else if the node has one child, copy the child to the node to be deleted and delete the
child node.
13. Else if the node has two children, find the inorder successor of the node.
14. Copy the contents of the inorder successor to the node to be deleted and delete the
inorder successor.
Program:
class Node:
self.key = key
self.left = None
self.right = None
def inorder(root):
inorder(root.left)
print(str(root.key) + "->", end=' ')
inorder(root.right)
if node is None:
return Node(key)
else:
return node
def minValueNode(node):
current = node
current = current.left
return current
if root is None:
return root
else:
if root.left is None:
temp = root.right
root = None
return temp
temp = root.left
root = None
return temp
temp = minValueNode(root.right)
root.key = temp.key
return root
root = None
root = insert(root, 8)
root = insert(root, 3)
root = insert(root, 1)
root = insert(root, 6)
root = insert(root, 7)
root = insert(root, 4)
inorder(root)
print("\nDelete 4")
root = deleteNode(root, 4)
inorder(root)
print("\nDelete 6")
root = deleteNode(root, 6)
print("Inorder traversal: ", end=' ')
inorder(root)
print("\nDelete 3")
root = deleteNode(root, 3)
inorder(root)
Output:
Inorder traversal: 1-> 3-> 4-> 6-> 7-> 8-> 10-> 14->
Delete 4
Inorder traversal: 1-> 3-> 6-> 7-> 8-> 10-> 14->
Delete 6
Inorder traversal: 1-> 3-> 7-> 8-> 10-> 14->
Delete 3
Inorder traversal: 1-> 7-> 8-> 10-> 14->
Result:
Ex.No:10b Implementation Of AVL Tree
Date:
Aim:
Algorithm:
Program:
import sys
class TreeNode(object):
self.key = key
self.left = None
self.right = None
self.height = 1
class AVLTree(object):
if not root:
return TreeNode(key)
else:
root.height = 1 + max(self.getHeight(root.left),
self.getHeight(root.right))
balanceFactor = self.getBalance(root)
if balanceFactor > 1:
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
if not root:
return root
else:
if root.left is None:
temp = root.right
root = None
return temp
temp = root.left
root = None
return temp
temp = self.getMinValueNode(root.right)
root.key = temp.key
root.right = self.delete_node(root.right,
temp.key)
if root is None:
return root
root.height = 1 + max(self.getHeight(root.left),
self.getHeight(root.right))
balanceFactor = self.getBalance(root)
if balanceFactor > 1:
if self.getBalance(root.left) >= 0:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if self.getBalance(root.right) <= 0:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
T2 = y.left
y.left = z
z.right = T2
z.height = 1 + max(self.getHeight(z.left),
self.getHeight(z.right))
y.height = 1 + max(self.getHeight(y.left),
self.getHeight(y.right))
z.height = 1 + max(self.getHeight(z.left),
self.getHeight(z.right))
y.height = 1 + max(self.getHeight(y.left),
self.getHeight(y.right))
return y
if not root:
return 0
return root.height
if not root:
return 0
return self.getHeight(root.left) - self.getHeight(root.right)
return root
return self.getMinValueNode(root.left)
if not root:
return
self.preOrder(root.left)
self.preOrder(root.right)
currPtr != None:
sys.stdout.write(indent)if
last:
print(currPtr.key)
myTree = AVLTree()
root = None
nums = [15,20,24,10,13,7,30,36,25]
key = 24
key = 20
key = 15
R --- 13
L --- 10
| L --- 7
R --- 24
L ---20
| L --- 15
R --- 30
L --- 25
R--- 36
After Deletion:
R --- 13
L --- 10
| L --- 7
R --- 25
L ---20
| L --- 15
R --- 30
R--- 36
After Deletion:
R --- 13
L --- 10
| L --- 7
R --- 25
L ---15
R --- 30
R--- 36
After Deletion:
R --- 13
L --- 10
| L --- 7
R --- 30
L ---25
R --- 36
Result:
Ex.No:11a Implementation Of Max heap
Date:
Aim:
Algorithm:
Output:
Max-Heap array: [44, 42, 35, 33, 14, 19, 27, 10, 26]
After deleting an element: [42, 33, 35, 26, 14, 19, 27, 10]
After deleting an element: [42, 26, 35, 10, 14, 19, 27]
Result:
Ex.No:11b Implementation Of Min heap
Date:
Aim:
Output:
Min heap:
[1, 3, 2, 9, 4, 5]
Result:
Ex.No:12a Implementation Of Graph Representation Using Adjacency List
Date:
Aim:
To write a program to implement graph representation using Adjacency list
Algorithm:
Program:
class AdjNode:
self.vertex = data
self.next = None
class Graph:
self.V = vertices
node = AdjNode(dest)
node.next = self.graph[src]
self.graph[src] = node
node = AdjNode(src)
node.next = self.graph[dest]
self.graph[dest] = node
def print_graph(self):
for i in range(self.V):
while temp:
temp = temp.next
print(" \n")
V=5
graph = Graph(V)
graph.add_edge(0, 1)
graph.add_edge(0, 4)
graph.add_edge(1, 2)
graph.add_edge(1, 3)
graph.add_edge(1, 4)
graph.add_edge(2, 3)
graph.add_edge(3, 4)
graph.print_graph()
Output
Result:
Ex.No:12b Implementation Of Graph Representation Using Adjacency Matrix
Date:
Aim:
To write a program to implement graph representation using Adjacency matrix
Algorithm:
Program:
class Graph:
n=0
self. g[i][j]= 0
def displayAdjacencyMatrix(self):
print()
if(x == y):
else:
self. g[y][x]= 1
self. g[x][y]= 1
def addVertex(self):
self. n = self. n + 1;
if(x>self. n):
print("Vertex not present !")
else:
while(x<self. n):
x=x+1
self. n = self. n - 1
obj = Graph(4);
obj.addEdge(0, 1);
obj.addEdge(0, 2);
obj.addEdge(1, 2);
obj.addEdge(2, 3);
obj.displayAdjacencyMatrix();
#obj.addVertex();
#obj.addEdge(4, 1);
#obj.addEdge(4, 3);
obj.displayAdjacencyMatrix();
obj.removeVertex(1);
obj.displayAdjacencyMatrix();
Output
Adjacency Matrix:
0110
1010
1101
0010
Adjacency Matrix:
0110
1010
1101
0010
Adjacency Matrix:
010
101
010
Result:
Ex.No:12c Implementation Of Graph Traversal Algorithm Using BFS
Date:
Aim:
To write a program to implement graph traversal algorithm using BFS
Algorithm:
1. Start by putting any one of the graph's vertices at the back of a queue.
2. Take the front item of the queue and add it to the visited list.
3. Create a list of that vertex's adjacent nodes. Add the ones which aren't in the visited list to
the back of the queue.
4. Keep repeating steps 2 and 3 until the queue is empty.
Program
graph = {'A': ['B', 'C', 'E'],
'B': ['A','D', 'E'],
'C': ['A', 'F', 'G'],
'D': ['B'],
'E': ['A', 'B','D'],
'F': ['C'],
'G': ['C']}
def bfs_connected_component(graph, start):
explored = []
queue = [start]
while queue:
node = queue.pop(0)
if node not in explored:
explored.append(node)
neighbours = graph[node]
for neighbour in neighbours:
queue.append(neighbour)
return explored
bfs_connected_component(graph,'A')
Output:
['A', 'B', 'C', 'E', 'D', 'F', 'G']
Result:
Ex.No:12d Implementation Of Graph Traversal Algorithm Using DFS
Date:
Aim:
To write a program to implement graph traversal algorithm using DFS
Algorithm:
1. Create a recursive function that takes the index of the node and a visited array.
2. Mark the current node as visited and print the node.
3. Traverse all the adjacent and unmarked nodes and call the recursive function with the
index of the adjacent node.
4. Run a loop from 0 to the number of vertices and check if the node is unvisited in the
previous DFS, call the recursive function with the current node.
Program:
def recursive_dfs(graph, source,path = []):
if source not in path:
path.append(source)
if source not in graph:
return path
for neighbour in graph[source]:
path = recursive_dfs(graph, neighbour, path)
return path
graph = {"A":["B","C", "D"],
"B":["E"],
"C":["F","G"],
"D":["H"],
"E":["I"],
"F":["J"]}
path = recursive_dfs(graph, "A")
print(" ".join(path))
Output:
DFS
ABEICFJGDH
Result:
Ex.No:13 Implementation Of Single source shortest path algorithm
Date:
Aim:
To write a program to implement single source shortest path algorithm
Algorithm:
1. Start with a weighted graph
2. Choose a starting vertex and assign infinity path values to all other vertices
3. Go to each vertex and update its path length
4. If the path length of the adjacent vertex is lesser than new path length, don’t update it
5. Avoid updating path length of already visited vertices
6. After each iteration pick the unvisited vertiex with the least path length
7. Repeat until all verties have been visited
Program:
import heapq
def calculate_distances(graph, starting_vertex):
distances = {vertex: float('infinity') for vertex in graph}
distances[starting_vertex] = 0
pq = [(0, starting_vertex)]
while len(pq) > 0:
current_distance, current_vertex = heapq.heappop(pq)
if current_distance > distances[current_vertex]:
continue
for neighbor, weight in graph[current_vertex].items():
distance = current_distance + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))
return distances
example_graph = {
'v1': {'v2': 2, 'v4': 1,},
'v2': {'v4': 3, 'v5': 10,},
'v3': {'v1': 4,},
'v4': {'v3': 2, 'v6': 8, 'v7': 4, 'v5': 2},
'v5': {'v7': 6,},
'v6': {'v3': 5,},
'v7': {'v6': 1,},
}
print(calculate_distances(example_graph, 'v1'))
Output:
shortest path
{'v1': 0, 'v2': 2, 'v3': 3, 'v4': 1, 'v5': 3, 'v6': 6, 'v7': 5}
Result:
Ex.No:14a Implementation Of Minimum spanning tree algorithm Using Kruskal’s
Date: algorithm
Aim:
Algorithm:
1. Sort all the edges in non-decreasing order of their weight.
2. Pick the smallest edge.
3. Check if it forms a cycle with the spanning tree formed so far.
4. If cycle is not formed, include this edge. Else, discard it.
5. 3. Repeat step2 until there are (V-1) edges in the spanning tree.
Program:
class Edge :
Result
Ex.No:14b Implementation Of Minimum spanning tree algorithm Using Prim’s
Date: algorithm
Aim:
Algorithm:
Result: