21CSC204J - Design and Analysis of Algorithms

LAB MANUAL

Bachelor of Technology
IV Semester

Academic Year 2023-2024 (EVEN)

TIRUCHIRAPPALLI

FACULTY OF ENGINEERING AND TECHNOLOGY

SRM INSTITUTE OF SCIENCE AND
TECHNOLOGY TIRUCHIRAPPALLI

1
 List of Experiments

Subject Code : 21CSC204J Subject Name: Design and Analysis of Algorithms

E.No List of Experiments

1 Simple Algorithm-Insertion sort

2
Bubble Sort
3 Recurrence Type-Merge sort, Linear search
4 Quicksort, Binary search
5 Strassen Matrix multiplication
6 Finding Maximum and Minimum in an array, Convex Hull problem
7 Huffman coding, knapsack and using greedy
8 Various tree traversals
9 Longest common subsequence
10

11 Travelling salesman problem

12 BFS and DFS implementation with array
13 Randomized quick sort
14 String matching algorithms
15 Discussion over analyzing a real time problem

2
 Lab 1: Simple Algorithm-Insertion sort
Aim : Write an algorithm for sorting the given elements using Insertion sort
Algorithm:
1. If it is the first element, it is already sorted. return 1;
2. Pick next element
3. Compare with all elements in the sorted sub-list
4. Shift all the elements in the sorted sub-list that is greater than the value to be sorted
5. Insert the value
6. Repeat until list is sorted

Lab 2: Bubble Sort

Aim : Write an algorithm for sorting the given elements using Bubble sort
Algorithm:
1. Check if the first element in the input array is greater than the next element in the array.
2. If it is greater, swap the two elements; otherwise move the pointer forward in the array.
3. Repeat Step 2 until we reach the end of the array.
4. Check if the elements are sorted; if not, repeat the same process (Step 1 to Step 3) from the
last element of the array to the first.
Lab 3: Recurrence Type-Merge sort, Linear search
Aim : Write an algorithm to perform various tree traversals
Merge Sort Algorithm:
1. Divide the input list into two equal-sized sublists.
2. Recursively sort the two sublists.
3. Merge the two sorted sublists together to obtain the final sorted list..

Linear Search:

Algorithm Linear Search ( Array Arr, Value a ) // Arr is the name of the array, and a is the
searched element.

Step 1: Start

Step 2: Intialize i = 0

Step 3: if i > n then go to step 8 Step

4: if Arr[i] = a then go to step 7 Step

5: Set i to i + 1

Step 6: Goto step 3

Step 7: Print element a found at index i and go to step 9

Step 8: Print element not found
Step 8: Exit
3
Lab 4: Binary Search , Quick Sort
Aim : Write an algorithm for binary search and quick sort.
Algorithm: Binary Search
Step: 1 Start by defining the search interval/space: the entire array or list in the beginning.
Step: 2 Divide the search space into two halves by finding the midpoint.
Step: 3 Compare the middle element of the search space with the key.
Step: 4 If the key matches with the middle element, the search is complete and the index of
the value is returned. The process is terminated.
Step: 5 If the key does not match with the middle element, choose which half will be used as
the next search space.
If the key is smaller than the middle element, the left half is used for the next search. If the
key is larger than the middle element, the right side is used for the next search.
Step: 6 Again start with step 2.
Step: 7 This process is continued until the key is found or the total search space is
exhausted.

Quicksort:
Step 1: Select a pivot element
Step 2: Partition the array around the pivot element.
Move all the elements < pivot to the left of the pivot and move all elements >= pivot to the

Step 3: After Step 2, the pivot element is in its correct position Step 4: Apply the quicksort
recursively on the left partition Step 5: Apply the quicksort recursively on the right partition
Step 6: Stop the recursion when the base case is reached. The base case is an array of size
zero or one
Lab 5 : Multiplication
Aim : Write an algorithm to implement Multiplication
Algorithm:
Algorithm STRASSEN_METHOD (A, B, C, int n) if n == 1 then
C = C + (A) * (B)
else
STRASSEN_METHOD (A, B, C, n/4)
STRASSEN_METHOD (A, B + (n/4), C + (n/4), n/4)
STRASSEN_METHOD (A + 2 * (n/4), B, C + 2 * (n/4), n/4)
STRASSEN_METHOD (A + 2 * (n/4), B + (n/4), C + 3 * (n/4), n/4)
STRASSEN_METHOD (A + (n/4), B + 2 * (n/4), C, n/4)
STRASSEN_METHOD (A + (n/4), B + 3 * (n/4), C + (n/4), n/4) STRASSEN_METHOD
(A + 3 * (n/4), B + 2 * (n/4), C + 2 * (n/4), n/4) STRASSEN_METHOD (A + 3 * (n/4), B +
3 * (n/4), C + 3 * (n/4), n/4)
end
Lab 6: Finding Maximum and Minimum in an array, Convex Hull problem
Aim : Write an algorithm for finding Maximum and Minimum in an array, Convex
Hull problem

4
Algorithm:
Finding Maximum and Minimum in an array
Divide array by calculating mid index i.e. mid = l + (r l)/2
Recursively find the maximum and minimum of left part by calling the same
function i.e. leftMinMax[2] = minMax(X, l, mid)
Recursively find the maximum and minimum of right part by calling the same
function i.e. rightMinMax[2] = minMax(X, mid + 1, r)
Finally, get the overall maximum and minimum by comparing the min and max of
both halves.

Convex Hull problem

Find the point with minimum x-coordinate lets say, min_x and similarly the point
with maximum x-coordinate, max_x.

Make a line joining these two points, say L. This line will divide the whole set into
two parts. Take both the parts one by one and proceed further.

For a part, find the point P with maximum distance from the line L. P forms a
triangle with the points min_x, max_x. It is clear that the points residing inside this
triangle can never be the part of convex hull.

The above step divides the problem into two sub-problems (solved recursively).
Now the line joining the points P and min_x and the line joining the points P and
max_x are new lines and the points residing outside the triangle is the set of points.
Repeat point no. 3 till there no point left with the line. Add the end points of this
point to the convex hull.
Lab 7: Huffman coding, knapsack and using greedy
Aim : Write an algorithm for Huffman Coding and Knapsack using Greedy Approach

5
Algorithm:
Huffman Coding
Input is an array of unique characters along with their frequency of occurrences and output
is Huffman Tree.
Create a leaf node for each unique character and build a min heap of all leaf nodes
(Min Heap is used as a priority queue. The value of frequency field is used to
compare two nodes in min heap. Initially, the least frequent character is at root)
Extract two nodes with the minimum frequency from the min heap.
Create a new internal node with a frequency equal to the sum of the two nodes
frequencies. Make the first extracted node as its left child and the other extracted
node as its right child. Add this node to the min heap.
Repeat steps#2 and #3 until the heap contains only one node. The remaining node is
the root node and the tree is complete.
Knapsack Problem
Sort items by the ratio value/weight for each item, in descending order.
Start with the highest ratio item. Put items into the bag until the next item on the list
cannot fit.
Try to fill any remaining capacity with the next item on the list that can fit.
Lab 8: Various tree traversals
Aim : Write an algorithm to perform various tree traversals
Algorithm:

Pre-order Traversal
Return the root node value.

Traverse the left subtree by recursively calling the pre-order function.

Traverse the right subtree by recursively calling the pre-order function.

In-order Traversal
Traverse the left subtree by recursively calling the in-order function.

Return the root node value.

Traverse the right subtree by recursively calling the in-order function.

Post-order Traversal
Traverse the left subtree by recursively calling the post-order function.
Traverse the right subtree by recursively calling the post-order function.
Return the root node value.
Lab 9: Longest common subsequence
Aim : Write an algorithm to find longest common subsequence

6
Algorithm:

Let X=<x1,x2,x3....,xm> and Y=<y1,y2,y3 ,ym> be the sequences. To compute the length of
an element the following algorithm is used.
Construct an empty adjacency table with the size, n × m, where n = size of sequence
X and m = size of sequence Y. The rows in the table represent the elements in
sequence X and columns represent the elements in sequence Y.
The zeroeth rows and columns must be filled with zeroes. And the remaining values
are filled in based on different cases, by maintaining a counter value.
Case 1 If the counter encounters common element in both X and Y sequences,
increment the counter by 1.
Case 2 counter does not encounter common elements in X and Y sequences
at T[i, j], find the maximum value between T[i-1, j] and T[i, j-1] to fill it in T[i, j].
Once the table is filled, backtrack from the last value in the table. Backtracking here
is done by tracing the path where the counter incremented first.
The longest common subsequence obtained by noting the elements in the traced
path.
Lab10: N problem
Aim : Write an algorithm to solve N problem
Algorithm:
Start in the leftmost column
If all queens are placed return true
Try all rows in the current column. Do the following for every row.
If the queen can be placed safely in this row
Then mark this [row, column] as part of the solution and
recursively check if placing queen here leads to a solution.
If placing the queen in [row, column] leads to a solution then
return true.
If placing queen lead to a solution then unmark this [row,
column] then backtrack and try other rows.
If all rows have been tried and valid solution is not found return false to
trigger backtracking.
Lab11: Travelling salesman problem

Aim : Write an algorithm to perform travelling salesman problem

7
Algorithm:
Travelling salesman problem
Input : G= {V, E} Output Gout = {V,E}

Start

Get the vextex and edges in the form of matrix.

Sort all the edges in the input graph G from the least distance to the largest distance.

The first edge selected is the edge with least distance, and one of the two vertices
(say A and B) being the origin node (say A).

Then among the adjacent edges of the node other than the origin node (B), find the
least cost edge and add it onto the output graph.

Continue the process with further nodes making sure there are no cycles in the
output graph and the path reaches back to the origin node A.

However, if the origin is mentioned in the given problem, then the solution must
always start from that node only. Let us look at some example problems to
understand this better.

End

Lab 12: BFS and DFS implementation with array

Aim: Write an algorithm to perform breadth first search and death first search of a graph

8
Algorithm

Start

Get the input graph in the form of matrix

Initialize the enqueue the starting node into a queue and mark it as visited.

Repeat While the queue is not empty:

Dequeue a node from the queue and visit it (e.g., print its value).

For each unvisited neighbor of the dequeued node:

Enqueue the neighbor into the queue.

Mark the neighbor as visited.

Repeat step 2 until the queue is empty.

Print the visited node

Stop

Algorithm for DFS

Start
First, create a stack with the total number of vertices in the graph.
choose any vertex as the starting point of traversal, and push that vertex into the
stack.
Push a non-visited vertex (adjacent to the vertex on the top of the stack) to the top
of the stack.
Repeat steps 3 and 4 until no vertices are left to visit from the vertex on the stack's
top.
If no vertex is left, go back and pop a vertex from the stack.
Repeat steps 2, 3, and 4 until the stack is empty

End
Lab 13: Randomized quick sort

Aim: Write an algorithm to perform randomized quick sort

9
 Algorithm:
Start
An array is divided into subarrays by selecting a pivot element.
Divide the array, the pivot element should be positioned in such a way that elements
less than pivot are kept on the left side and elements greater than pivot are on the
right side of the pivot
The left and right subarrays are also divided using the same approach. This process
continues until each subarray contains a single element.
At this point, elements are already sorted. Finally, elements are combined to form a
sorted array.
Stop
Lab14: String matching algorithms

Aim: Write an algorithm too perform string matching

Algorithm:

Start
Get the input string and substring
Repeat
Compare the pattern with every substring of the text until a match is found.
Print output
End

Lab15: Discussion over analyzing a real time problem

Students were asked to solve following applications
Graph API uses the structure of Graphs.
Dijkstra algorithm or the shortest path first algorithm also uses graph structure to
find the smallest path between the nodes of the graph
Networking components have a huge application for graph
Google map to find nearest location.
Facebook to suggest mutual friends

Course Coordinator Prepared By

Dr. L. Josephine Usha Dr.M. Devipriya Priya
Dr. L. Josephine Usha
Dr.P. Shanmuga Sundari

10