2316043

Practical -1

Aim:

Sort a given set of elements using Insertion sort method and determine the time required to sort
the elements. Plot the graph of the time taken versus n. The elements can be generated using
random number generator.

Pseudo Code for Insertion Sort:

Insertion-Sort (A)

for j = 2 to A.length()
key = A[ j ]
// Insert A[ j ] into the sorted sequence A[ 1….j-1 ]
i = j -1
while i > 0 and A[ i ] > key
A [ i +1 ] = A [ i ]
i=i–1
A[ i + 1 ] = key

Code:
import time

import numpy.random as np

import matplotlib.pyplot as plt

list1=[]

def insertion_sort(A):

for j in range(2,len(A)):

key=A[j]

i=j-1

while i>-1 and A[i]>key:

A[i+1]=A[i]

1
 2316043
i=i-1

A[i+1]=key

list2=[]

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

A=np.randint(i, 900,i*1000)

list1.append(len(A))

Starttime=time.clock()

insertion_sort(A)

endtime=time.clock()

list2.append(endtime - Starttime)

plt.plot(list1,list2)

print(list1, "\n", list2)

Output:
[5000, 4000, 3000, 2000, 1000]
[4.181740838952919, 2.6366416284978413, 1.5231062973732605,
0.6836392882361224, 0.16351879782666856]

2
 2316043

Practical – 2

Aim:

Sort a given set of elements using Merge sort and determine the time required to sort the
elements. Plot a graph of time taken versus n. The elements can be generated random number
generator.

Pseudo Code for Merge Sort:

Merge ( A , p , q , r )

n1  q – p +1

n2  r – q
create arrays L [ 1..…n1+1] & R [ 1……n2+1]
for i  1 to n1
do L[ i ]  A[ p + i -1 ]
for j  1 to n2
do R[ j ]  A[ q + p]
L[ n1 + 1]  ∞

R[ n2 + 1]  ∞

I1
J1
for k  p to r
do if L[ i ] <= R[ j ]
A[ k ]  L [ i ]
i  i+1
else
A[k] R[j]
Jj+1

Merge_Sort ( A , p , r )

if p < r then
q  L [ ( p + (r -1))//2 ]
Merge_Sort ( A , p, q )

3
 2316043

Merge_Sort ( A , q+1 , r )
Merge ( A , p , q , r )

Code:
import time

import numpy.random as np

import matplotlib.pyplot as plt

list1=[]

def merge(arr,p,q,r):

n1=q-p+1

n2=r-q

L=[0]*(n1)

R=[0]*(n2)

for i in range(0,n1):

L[i]=arr[p+i]

for j in range(0,n2):

R[j]=arr[q+1+j]

i=0

j=0

k=1

while(i<n1 and j<n2):

if(L[i]<=R[j]):

arr[k]=L[i]

i+=1

else:

arr[k]=R[j]

j+=1

4
 2316043
k+=1

while i<n1:

arr[k]=L[i]

i+=1

k+=1

while j<n2:

arr[k]=R[j]

j+=1

k+=1

def mergeSort(arr,p,r):

if p<r:

q=(p+(r-1))//2

mergeSort(arr,p,q)

mergeSort(arr,q+1,r)

merge(arr,p,q,r)

list2=[]

for i in range(0,5,1):

arr=np.randint(i, 900,i*1000)

list1.append(len(arr))

Starttime=time.clock()

mergeSort(arr,0,len(arr)-1)

endtime=time.clock()

list2.append(endtime - Starttime)

plt.plot(list1,list2)

print(list1, "\n", list2)

5
 2316043

Output:
[0, 1000, 2000, 3000, 4000]
[2.133328784736932e-06, 0.00887720772862366, 0.01926822556112029,
0.03390627433328319, 0.057405744201076914]

--

6
 2316043

Practical – 3

Aim:

Sort a given set of elements using Quick sort and determine the time required to sort the
elements. Plot a graph of time taken versus n. The elements can be generated random number
generator.

Algorithm:

Quick_Sort ( A, p , r )

if p < r then

q  Partition ( A , p , r )

Quick_Sort ( A , p , q-1 )
Quick_Sort ( A , q+1 , r )

Partition ( A , p , r )

XA[r]

i  p -1
for j  p to r-1
do if A[ j ] <= x then
i  i +1
Exchange A[ i ]  A[ j ]
Exchange A[ i+1 ]  A[ r ]
return i+1

Code:
import time

import numpy.random as np

import matplotlib.pyplot as plt

list1=[]

def partition(A,p,r):

7
 2316043
pivot=A[r]

i=p-1

for j in range(p,r):

if A[j]<=pivot:

i=i+1

A[i],A[j]=A[j],A[i]

A[i+1],A[r]=A[r],A[i+1]

return (i+1)

def quicksort(A,p,r):

if p<r:

q=partition(A,p,r)

quicksort(A,p,q-1)

quicksort(A,q+1,r)

list2=[]

A = None

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

A=np.randint(i, 900,i*1000)

list1.append(len(A))

Starttime=time.clock()

quicksort(A,0,len(A)-1)

endtime=time.clock()

list2.append(endtime - Starttime)

plt.plot(list1,list2)

print(list1, "\n", list2)

8
 2316043

Output:
[5000, 4000, 3000, 2000, 1000]
[0.04519831225363902, 0.03296019772623282, 0.024484453939617623,
0.013818320519646932, 0.006184599314458694]

9
 2316043

Practical – 4

Aim:

Sort a given set of elements using Heap sort and determine the time required to sort the elements.
Plot a graph of time taken versus n. The elements can be generated random number generator

Algorithm:
MaxHeapify(A, i)

    l  left(i) # left(i) = 2*i + 1

    r  right(i) #right(i)=2*i +2

    if l <= heap-size[A] and A[l] > A[i]

        then largest  l

        else largest  i

    if r <= heap-size[A] and A[r] > A[largest]

        then largest  r

    if largest != i

        then swap A[i] with A[largest]

        MaxHeapify(A, largest)

end function

BuildMaxHeap(A)

    heap-size[A]  length[A]

    for i  length[A] to -1

        do MaxHeapify(A, i)

end function

HeapSort(A)

    BuildMaxHeap(A)

10
 2316043

    for i = length[A]-1 to 0

        do swap A[1] with A[i]

            heap-size[A] = heap-size[A] – 1

            MaxHeapify(A, 1)

end function

Code:
import numpy.random as np

import matplotlib.pyplot as plt

import time

class Heap:

def __init__(self):

self.arr = None

self.size = None

def left(i):

return 2*i+1

def right(i):

return 2*i+2

def max_heapify(heap,i):

L=left(i)

R=right(i)

#print(i)

if L < heap.size and heap.arr[L]>heap.arr[i]:

largest=L

else:

largest=i

11
 2316043
if R < heap.size and heap.arr[R]>heap.arr[largest]:

largest=R

if largest != i:
heap.arr[i],heap.arr[largest]=heap.arr[largest],heap.arr[i]

max_heapify(heap,largest)

def build_max_heap(heap):

for i in range(heap.size//2,-1,-1):

max_heapify(heap,i)

def heap_sort(heap):

build_max_heap(heap)

for i in range(heap.size-1,0,-1):

heap.arr[i],heap.arr[0] = heap.arr[0],heap.arr[i]

heap.size -= 1

max_heapify(heap,0)

list2=[]

list1 = []

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

heap = Heap()

heap.arr = np.randint(i, 800,50*i)

heap.size = len(heap.arr)

list1.append(heap.size)

Starttime=time.clock()

heap_sort(heap)

endtime=time.clock()

list2.append(endtime - Starttime)
12
 2316043
print(list1)

print(list2)

plt.plot(list1,list2)

plt.show()

Output:

13
 2316043

Practical-5

Aim:
a. Print all the nodes reachable from a given starting node in a digraph using BFS method.
b. Check whether a given graph is connected or not using DFS method.

Algorithm:

bfs(graph, root)

visited, queue  list(), deque([root])

visited.append(root)

while queue

vertex  queue.popleft()

for neighbour in nx.neighbors(graph, vertex):

if neighbor is not visited

visited.append(neighbour)

queue.append(neighbour)

return visited

dfs(graph,root,visited = None)

if visited == None

visited  list()

visited.append(root)

for neighbor in nx.neighbors(graph, root)

if neighbor is not visited

dfs(graph,neighbor,visited)

return visited

14
 2316043

Code:
import networkx as nx

from matplotlib import pyplot as plt

from _collections import deque

def bfs(graph, root):

visited, queue = list(), deque([root])

visited.append(root)

while queue:

vertex = queue.popleft()

for neighbour in nx.neighbors(graph, vertex):

if neighbour not in visited:

visited.append(neighbour)

queue.append(neighbour)

return visited

def dfs(graph,root,visited = None):

if visited == None:

visited = list()

visited.append(root)

for neighbor in nx.neighbors(graph, root):

if neighbor not in visited:

dfs(graph,neighbor,visited)

return visited

G = nx.DiGraph()

G.add_edge(5,1)
15
 2316043
G.add_edge(1,2)

G.add_edge(2,3)

G.add_edge(2,5)

G.add_edge(5,3)

G.add_edge(2,1)

G.add_edge(3,4)

nx.draw_networkx(G)

plt.show()

print("BFS : " ,bfs(G, 1))

print("DFS : " ,dfs(G, 1))

Output:

16
 2316043

Practical – 6

Aim:

To implement Longest Common Subsequence.

Algorithm:
lcs(X,Y,m,n)

if(m==0 or n==0)

return (0)

elif(X[m-1]==Y[n-1])

return (1+lcs(X,Y,m-1,n-1))

else:

return max(lcs(X,Y,m,n-1),lcs(X,Y,m-1,n))

Code:
def lcs(X,Y,m,n):

if(m==0 or n==0):

return (0)

elif(X[m-1]==Y[n-1]):

return (1+lcs(X,Y,m-1,n-1))

else:

return max(lcs(X,Y,m,n-1),lcs(X,Y,m-1,n))

X="knowledge"

Y="pledge"

print("length of lcs is ",lcs(X,Y,len(X),len(Y)))

Output:

17
 2316043

Practical – 7

Aim:
Compute the transitive closure of a given directed graph using Warshall's algorithm.

Algorithm:

for k  1 to n do

for I  1 to n do

for j 1 to n do

R(k-1)[i,j]  R(k-1) [i,j] or (R(k-1) [i,k] and R(k-1) [k,j])

return R(n)

Code:
import networkx as nx

from matplotlib import pyplot as plt

def printSolution(reach):

ll=[]

print ("Following matrix transitive closure of the given graph ")

for i in range(4):

l=[]

for j in range(4):

l.append(reach[i][j])

ll.append(l)

for row in ll:

for elem in row:

print(elem, end=' ')

print()

def transitiveClosure(graph):

reach =[i[:] for i in graph]

18
 2316043
for k in range(4):

for i in range(4):

for j in range(4):

reach[i][j] = reach[i][j] or (reach[i][k] and reach[k]

[j])

printSolution(reach)

G = nx.DiGraph()

G.add_edge(1,1)

G.add_edge(1,2)

G.add_edge(1,3)

G.add_edge(2,2)

G.add_edge(2,3)

G.add_edge(3,3)

G.add_edge(3,4)

G.add_edge(4,4)

G.add_edge(4,3)

nx.draw_networkx(G)

plt.show()

graph = [[1, 1, 0, 1],

[0, 1, 1, 0],

[0, 0, 1, 1],

[0, 0, 1, 1]]

transitiveClosure(graph)

19
 2316043

Output:

20
 2316043

Practical – 8

Aim:

Implement N Queen's problem using Back Tracking.

Algorithm:

1. Create a class QueenChessBoard.

2. The board configuration is stored in a list called columns where if c = columns[r], then a queen is at
column c and row r.
3. The class provides methods to place a queen in the next row given the column, remove the queen from
the last row where a queen is present, check whether a given column is safe to place a queen in the next
free row and to display the board.
4. Define the function solve_queen that takes the size of the board as argument.
5. It creates a QueenChessBoard object with that size.
6. A while loop is created with condition True.
7. In each iteration, it is checked to see in which column a queen can be placed in the first available row
of the board. This is done using another loop inside the while loop.
8. If such a column is there, the queen is placed there and the inner loop is stopped.
9. After the inner loop, if a column was not found or the board became full, then we need to backtrack.
10. If the board is full, then before backtracking, we need to display the board.
11. Backtracking is done by removing the queen from the last filled row and making the next iteration try
column values above the column values of the queen just removed.
12. If it is found that no more queens can be removed, then we are finished.
13. The number of solutions is kept track of and printed at the end.

Code:

class QueenChessBoard:

def __init__(self, size):

self.size = size

self.columns = []

def place_in_next_row(self, column):

self.columns.append(column)

def remove_in_current_row(self):

21
 2316043
return self.columns.pop()

def is_this_column_safe_in_next_row(self, column):

row = len(self.columns)

for queen_column in self.columns:

if column == queen_column:

return False

for queen_row, queen_column in enumerate(self.columns):

if queen_column - queen_row == column - row:

return False

for queen_row, queen_column in enumerate(self.columns):

if ((self.size - queen_column) - queen_row

== (self.size - column) - row):

return False

return True

def display(self):

for row in range(self.size):

for column in range(self.size):

if column == self.columns[row]:

print('Q', end=' ')

else:

print('.', end=' ')

print()

def solve_queen(size):

board = QueenChessBoard(size)

number_of_solutions = 0

row = 0

22
 2316043
column = 0

while True:

while column < size:

if board.is_this_column_safe_in_next_row(column):

board.place_in_next_row(column)

row += 1

column = 0

break

else:

column += 1

if (column == size or row == size):

if row == size:

board.display()

print()

number_of_solutions += 1

board.remove_in_current_row()

row -= 1

try:

prev_column = board.remove_in_current_row()

except IndexError:

break

row -= 1

column = 1 + prev_column

print('Number of solutions:', number_of_solutions)

n = int(input('Enter n: '))

solve_queen(n)

23
 2316043

Output:

24
 2316043

Practical – 9

Aim:

Obtain the Topological ordering of vertices in a given digraph

Algorithm:

Steps involved in finding the topological ordering of a DAG:

Step-1: Compute in-degree (number of incoming edges) for each of the vertex present in the DAG
and initialize the count of visited nodes as 0.
Step-2: Pick all the vertices with in-degree as 0 and add them into a queue (Enqueue operation)
Step-3: Remove a vertex from the queue (Dequeue operation) and then.
1. Increment count of visited nodes by 1.
2. Decrease in-degree by 1 for all its neighboring nodes.
3. If in-degree of a neighboring nodes is reduced to zero, then add it to the queue.
Step 5: Repeat Step 3 until the queue is empty.
Step 5: If count of visited nodes is not equal to the number of nodes in the graph then the topological
sort is not possible for the given graph.

Code:

import networkx as nx

from matplotlib import pyplot as plt

def TopologicalSort(graph):

TopologicalSortedList = []

ZeroInDegreeVertexList = []

inDegree = { u : 0 for u in graph }

for u in graph:

for v in graph[u]:

inDegree[v] += 1

for k in inDegree:

if (inDegree[k] == 0):

ZeroInDegreeVertexList.append(k)

while ZeroInDegreeVertexList:

v = ZeroInDegreeVertexList.pop(0)

TopologicalSortedList.append(v)

25
 2316043
for neighbour in graph[v]:

inDegree[neighbour] -= 1

if (inDegree[neighbour] == 0):

ZeroInDegreeVertexList.append(neighbour)

return TopologicalSortedList

graph = {

'1': set(['2','3']),

'2': set(['4']),

'3': set(['2','4']),

'4': set([])

G = nx.DiGraph()

G.add_edge(1,2)

G.add_edge(2,4)

G.add_edge(1,3)

G.add_edge(3,2)

G.add_edge(3,4)

nx.draw_networkx(G)

plt.show()

result = TopologicalSort(graph)

print("Topological sort >>> ", result)

if (len(result) == len(graph)):

print("Directed Acyclic Graph!")

else:

print("Graph has cycles!")

26
 2316043

Output

27
 2316043

Practical – 9

Aim:

To implement Huffman coding using Greedy algo.

Algorithm:

HUFFMAN(C)

n ← |C|

Q←C

for i 1 to n - 1

do allocate a new node z

left[z] ← x ← EXTRACT-MIN (Q)

right[z] ← y ← EXTRACT-MIN (Q)

f [z] ← f [x] + f [y]

INSERT(Q, z)

return EXTRACT-MIN(Q)

Code:
import heapq

from collections import defaultdict

def encode(frequency):

heap = [[weight, [symbol, '']] for symbol, weight in

frequency.items()]

heapq.heapify(heap)

while len(heap) > 1:

lo = heapq.heappop(heap)

hi = heapq.heappop(heap)

for pair in lo[1:]:

pair[1] = '0' + pair[1]

for pair in hi[1:]:

28
 2316043
pair[1] = '1' + pair[1]

heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])

return sorted(heapq.heappop(heap)[1:], key=lambda p: (len(p[-1]),

p))

data = "SHIVANI"

frequency = defaultdict(int)

for symbol in data:

frequency[symbol] += 1

huff = encode(frequency)

print ("Symbol".ljust(10) + "Weight".ljust(10) + "Huffman Code")

for p in huff:

print (p[0].ljust(10) + str(frequency[p[0]]).ljust(10) + p[1])

Output:

29