SRM Institute of Science and Technology

​ College of Engineering and Technology

​ School of Computing
SRM Nagar, Kattankulathur – 603203, Chengalpattu District, Tamil Nadu
Academic Year: 2022-23 (EVEN)

Test: CLA-T1​ ​ ​ ​ ​ ​ ​ Date:

Course Code & Title: 21CSC204J Design and Analysis of Algorithms Duration: 1 hour 40 min
Year & Sem: II Year / IV Sem​ ​ ​ ​ ​ Max. Marks: 50

Course Articulation Matrix: (to be placed)

Course PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12 Program Specific Outcomes
Outcome
PSO-1 PSO-2 PSO-3

CO1 2 1 2 1 - - - - 3 - 3 3 1 -
CO2 2 1 2 1 - - - - 3 - 3 3 1 -
CO3 2 1 2 1 - - - - 3 - 3 3 1 -
2 1 2 1 - - - - 3 - 3 3 1 -
CO4

CO5 2 1 2 1 - - - - 3 - 3 3 1 -

Part - A
(1 x 10 = 10 Marks)
Instructions: Answer all
Q. Question Marks BL CO PO PI
No Code
1 Assume that f(n) and g(n) are asymptotically 1 1 1 1-4,10, 1.1,
12
positive, then which of the following relation holds 1.3,
good? 2.4,
a.​ f(n)=O(g(n)) and g(n) = O(h(n)) then f(n) 12.2.2
=O(h(n)
b.​ f(n)=Ω(g(n)) and g(n) = O(h(n)) then f(n)
=Ω(h(n)
c.​ f(n)=Ω(g(n)) and g(n) = ϴ(h(n)) then f(n)
=Ω(h(n)
d.​ f(n)=O(g(n)) and g(n) = ϴ(h(n)) then f(n)
=Ω(h(n)

2 1 1 1 1-4,10, 1.1,
12
1.3,
2.4,
12.2.2

a.​ only I
b.​ only II
c.​ I or III or IV but not II
d.​ II or III or IV but not I
3 1 1 1 1-4,10, 1.1,
12
1.3,
2.4,
12.2.2

a.​ log n
b.​ log n * n
c.​ log n + 1
d.​ n

4 The Worst case occur in linear search algorithm 1 1 1 1-4,10, 1.1,

12
when _________​ 1.3,
a. Item is somewhere in the middle of the array​ 2.4,
b. Item is not in the array at all 12.2.2
c.Item is the last element in the array​
d. Item is the last element in the array or is not
there at all
5 The worst case complexity for insertion sort is 1 1 1 1-4,10, 1.1,
12
_________​ 1.3,
a) O(n)​ 2.4,
b) O(log n)​ 12.2.2
c) O(n^2)​
d) O(n log n)
6 If for an algorithm time complexity is given by 1 1 2 1-4,10, 1.1,
12
O(log2 100) then upper bounded complexity will be 1.3,
___________​ 2.4,
a) constant​ 12.2.2
b) polynomial​
c) linear​
d) none of the mentioned
7 What is the result of the recurrences? Let the 1 1 2 1-4,10, 1.1,
12
recurrence be given by T(n)=aT(n/b)+f(n) and 1.3,
f(n)=nc, when f(n) is O(nlogba-e) for some constant e> 2.4,
0, using Master’s theorem 12.2.2

𝑎
a) T(n) = 𝑂(𝑛 )
b) T(n) = O(nc log n)
c) T(n) = O(f(n))
d) T(n) = O(n2)
8 What is the worst case time complexity of a quick 1 1 2 1-4,10, 1.1,
12
sort algorithm?​ 1.3,
a) O(N)​ 2.4,
b) O(N log N)​ 12.2.2
c) O(N^2)​
d) O(log N)
9 What is the optimal time required for solving the 1 1 2 1-4,10, 1.1,
12
closest pair problem using divide and conquer 1.3,
approach? 2.4,
a) O(N) 12.2.2
b) O(log N)
c) O(N log N)
d) O(N^2)
10 What is the runtime efficiency of using brute force 1 1 2 1-4,10, 1.1,
12
technique for the closest pair problem? 1.3,
a) O(N) 2.4,
b) O(N log N) 12.2.2
c) O(N2)
d) O(N3 log N)
Part – B
(5 x 4 = 20 Marks)
Instructions: Answer All the Questions
11 Let t(n)=9n2. Prove that this is of the order of O(n2) 5 2 1 1-4,10, 1.1,
12
Answer: 1.3,
It can be observed from the given relation that, 9n2 2.4,
<=c* n2. This holds good for all values of c greater 12.2.2
than 9. Also, assuming c=9, the given relation holds
good. This is true n>= n0, where n0 =1. Therefore t(n)
ϵ O(n2)
12 Perform the complexity analysis of the following 2.5 2 1 1-4,10, 1.1,
12
algorithm segment. +2.5 1.3,
a) Algorithm Sample() 2.4,
Begin 12.2.2
loop i=1 to n
loop j=1 to m
A(i,j)=0
End loop
End loop
End

Answer :
Ans: O( n X m)
Here, the outer loop runs from 1 to n
In the inner loop runs from 1 to m

So, time complexity will be O(nm).

b) def fun(N):
for i in range(1,N+1)
j=N
while j>0:
j/=2

Answer: O( N x log (N))

Here, the outer loop runs from 1 to N
In the inner while loop, the j gets divided by 2 every
time.
So the inner loop will run for log2(j) = log2(N)
times.
As the inner loop runs for N times, our time
complexity will be N x log(N).

13 Compare and contrast Merge sort and Quick sort 5 2 2 1-4,10, 1.1,
12
Similarities: 1.3,
Divide and conquer: Both algorithms divide the input 2.4,
list recursively into smaller sub-lists, sort the 12.2.2
 sub-lists, and then merge them back together in the
correct order.
Average time complexity: Both have an average time
complexity of O(n log n), making them efficient for
large datasets.
Differences:

Methodology:

Merge Sort: Divides the list exactly in half and

merges the sorted halves. Requires extra space for
temporary storage.
Quick Sort: Chooses a pivot element and partitions
the list into elements less than and greater than the
pivot. More flexible partition ratios possible.
Requires no extra space.
Complexity:

Worst case time complexity:

Merge Sort: O(n log n) (guaranteed)
Quick Sort: O(n^2) (possible in certain cases where
pivot selection is poor)
14 Solve using substitution method 5 2 2 1-4,10, 1.1,
12
T(n)=T(n-1)+3; t(1)=4. 1.3,
Answer: 2.4,
T(n-1)= (T(n-2)+3)+3 12.2.2
T(n-2) =((T(n-3)+3)+3)+3
On generalizing,
T(i)= T(n-i) +i*3
When i=n-1, the resulting equation would be,
T(i)=T(1)+(n-1)*3
=4+3n -3
=3n +1
The solution of this recurrence equation is 3n+1
Part – C
(2 x 10 = 20 Marks)
Instructions: Answer All the Questions
15. Solve the following the recurrence relations using 10 3 1 1-4,10, 1.1,
12
A recursive tree method: 1.3,
a.​ T(n)= T(n/3) +T(2n/3)+n ; T(1)=1. 2.4,
b.​ T(n) = 8T(n/2) +1; T(1)=1. 12.2.2
 OR
15. Prove the following relations: 10 3 1 1-4,10, 1.1,
12
B a.​ T(n)=3n3+2n2+3; g(n) =n3; T(n) is in O(g(n)) 1.3,
Answer : 2.4,
12.2.2
 b.​ nϵ O(n2)
Answer: The given statement implies that
n <=c* n2. This is true n>= n0, where n0 =0 and
c>0. Therefore n ϵ O(n2)
16. Design an algorithm to arrange given integers in an 10 3 2 1-4,10, 1.1,
12
A array with running time complexity in O(nlogn) and 1.3,
prove the same. 2.4,
Answer: mergesort( array) 12.2.2
If len(array) > 1 Then
# This is the point where the array is divided into
two subarrays
halfArray = len(array) / 2

FirstHalf = array[:halfArray]
# The first half of the data set

SecondHalf = array[halfArray:]
# The second half of the data set

# Sort the two halves

mergeSort(FirstHalf)
mergeSort(SecondHalf)
merge(FirstHalf, SecondHalf)

k=0

Merge:
merge(FirstHalf, SecondHalf)
# Begin swapping values
While i < len(FirstHalf) and j < len(SecondHalf)
If FirstHalf[i] < SecondHalf[j] Then
array[k] = FirstHalf[i]
i += 1
Else
array[k] = SecondHalf[j]
j += 1
k += 1
EndIf
EndWhile
EndIf
OR
16. Justify the statement with an illustrative example 10 3 2 1-4,10, 1.1,
12
B “selection of pivot in Quick sort algorithm affects the 1.3,
running time” 2.4,
Answer: 12.2.2
The selection of the pivot in the Quick Sort
algorithm indeed has a significant impact on its
running time. Quick Sort works by partitioning an
array around a chosen pivot element, such that all
elements smaller than the pivot are placed before it,
and all elements greater than the pivot are placed
after it. Then, the algorithm recursively sorts the
subarrays created by the partitioning process.
Let's illustrate this with an example:

Consider an array of integers: [5, 9, 3, 7, 2, 8, 6].

Suppose we choose the first element, 5, as the pivot.

In this case, after the partitioning step, the array
might become [3, 2, 5, 9, 7, 8, 6], with the pivot 5
ending up in its sorted position.

Now, if the pivot is chosen poorly (for example,

always picking the first element in the array), and the
array is already sorted or nearly sorted, Quick Sort
degrades into its worst-case time complexity of
O(n^2). This happens because the partitioning step
doesn't effectively split the array into two roughly
equal halves, leading to one subarray significantly
larger than the other, causing inefficient recursive
calls.
Example 2:
Consider an unsorted array: [8, 3, 1, 4, 2, 7, 6, 5]

Choose a bad pivot: Let's pick the largest element,

which is 8 in this case.
Partition the array: All elements are less than 8,
resulting in: [1, 2, 3, 4, 5, 6, 7] | 8
Recursively sort both sub-arrays: We only have one
element on the left (8) and a sub-array of size n-1 on
the right. This creates a highly unbalanced situation
where one sub-array remains unsorted in each
recursive call.
This scenario continues, leading to n-1 comparisons
for each element in the worst case, resulting in a time
complexity of O(n^2).

However, if the pivot is chosen effectively, such as

selecting the median or a randomly chosen element,
Quick Sort achieves its average-case time complexity
of O(n log n). This is because a good pivot choice
ensures that the array is split into approximately
equal halves, leading to balanced partitions and
efficient sorting.