DAA Assignment Answers

(Module)
1) Explain the complexity of an algorithm with
its types
Ans: Algorithm complexity is a measure of the
resources an algorithm requires to execute as a
function of the size of the input. These
resources include time (execution time) and
space (memory). Evaluating complexity helps
understand the efficiency and scalability of an
algorithm.

Types of Algorithm Complexity

Time Complexity:

Time complexity refers to the amount of

computational time an algorithm takes to complete
as a function of the input size (n).
 It provides insights into the performance of an
algorithm as input size increases.
  Commonly expressed using Big-O notation,
which describes the upper bound of an
algorithm's growth rate.
Examples of Time Complexities:
1. O(1): Constant time - execution time does not
depend on input size (e.g., accessing an array
element).
2. O(log n): Logarithmic time - typically found
in divide-and-conquer algorithms like binary
search.
3. O(n): Linear time - execution time grows
proportionally with input size (e.g., linear
search).
4. O(n²): Quadratic time - often observed in
nested loops (e.g., Bubble Sort).
5. O(2ⁿ): Exponential time - observed in

algorithms like solving the Tower of Hanoi.

Space Complexity:

Space complexity refers to the amount of memory

an algorithm uses during execution, including:
 1. Fixed Space: Memory required for constants,
variables, and program instructions.
2. Variable Space: Memory required for
dynamic input data structures, recursion, etc.
Examples of Space Complexities:
1. O(1): Constant space - memory usage does not
depend on input size (e.g., swapping
variables).
2. O(n): Linear space - memory usage grows
linearly with input size (e.g., storing an array).

Types of Analysis for Complexity

Algorithm complexity is analysed in three
scenarios:
1. Best Case: Minimum time or space required
(e.g., searching the first element).
2. Worst Case: Maximum time or space required
(e.g., searching the last element).
3. Average Case: Expected time or space
considering all inputs.

2) Write a short note on BIGO Notation, Big

omega notation and BIG theta notation.
 Ans: In algorithm analysis, Big-O, Big-Omega,
and Big-Theta notations are used to describe
the performance and efficiency of algorithms in
terms of time and space complexity. They help
characterize how the execution time or space
requirements of an algorithm grow relative to
the size of the input.
Big-O Notation (O)
 Definition: Big-O describes the upper bound of
an algorithm's growth rate. It represents the worst-
case scenario, indicating the maximum time or
space an algorithm might take.
 Purpose: Helps ensure that the algorithm will not
exceed a certain time or space limit, even for large
inputs.

 Example: For a linear search, time complexity is

O(n)O(n)O(n), as the worst-case requires traversing
the entire array.

Big-Omega Notation (Ω)

  Definition: Big-Omega describes the lower
bound of an algorithm's growth rate. It
represents the best-case scenario, indicating
the minimum time or space an algorithm might
take.
 Purpose: Helps determine the guaranteed
performance of an algorithm under optimal
conditions.
 Mathematical Representation:

 Example: For a linear search, the best-case

time complexity is Ω(1)\Omega(1)Ω(1), as the
element might be found in the first position.

Big-Theta Notation (Θ)

 Definition: Big-Theta describes the tight
bound of an algorithm's growth rate. It
represents both the upper and lower bounds,
indicating that the time or space complexity of
the algorithm is the same in the best, worst,
and average cases.
 Purpose: Provides a precise measure of the
algorithm's efficiency.
 Mathematical Representation:

 Example: For merge sort, the time complexity

is Θ(nlog⁡n)\Theta(n \log n)Θ(nlogn), as it
always requires dividing and merging steps.
 MODULE 2
1) What is linear search, write it’s
algorithm and also write a python
program to implement linear search.
Ans: Linear search is a simple searching algorithm
that checks each element of a list or array
sequentially until the desired element (target) is
found or the end of the list is reached.
 Best Case: The target element is found at the
first position.
 Worst Case: The target element is not in the
list, or it is at the last position.
 Time Complexity:
o Best Case: O(1)O(1)O(1)

o Worst Case: O(n)O(n)O(n)

 Space Complexity: O(1)O(1)O(1), as it

requires no additional space.

Algorithm for Linear Search

1. Start at the first element of the list.
2. Compare the current element with the target
element.
3. If the current element matches the target,
return its index or position.
4. If the current element does not match, move to
the next element.
5. Repeat steps 2–4 until the end of the list.
6. If the target element is not found, return an
indication (e.g., -1).
 2) Explain the divide and conquer
algorithm Design techniques with its
advantages and disadvantages
Ans: The Divide and Conquer technique is an
algorithm design paradigm that solves a problem
by:
1. Dividing the problem into smaller sub
problems of the same type.
2. Conquering each sub problem recursively
until they become simple enough to solve
directly.
3. Combining the solutions of the sub problems
to solve the original problem.
Steps in Divide and Conquer
1. Divide: Break the problem into smaller,
independent subproblems.
2. Conquer: Solve each subproblem recursively.
 3. Combine: Merge the solutions of the
subproblems to form the solution to the
original problem.

Example Algorithms Using Divide and Conquer

1. Merge Sort: Divides the array into two
halves, sorts them recursively, and then
merges the sorted halves.
2. Quick Sort: Selects a pivot, partitions the
array around the pivot, and recursively sorts
the partitions.
3. Binary Search: Repeatedly divides the sorted
array into halves to locate the target element.
4. Matrix Multiplication (Strassen’s
Algorithm): Divides matrices into smaller
submatrices, multiplies them, and combines
the results.

Advantages of Divide and Conquer

1. Efficiency: Reduces the problem size in each
step, making it faster for large problems.
2. Parallelism: Subproblems are independent,
allowing for parallel processing.
 3. Modularity: Provides a clear structure by
breaking the problem into smaller parts.
4. Applicability: Works well for recursive
problems and problems with overlapping
subproblems.

Disadvantages of Divide and Conquer

 Overhead: Recursive calls add overhead in
terms of function calls and memory usage.
 Complex Implementation: Combining the
results of sub problems can be complex.
 Not Always Optimal: May not work efficiently
if sub problems are not of equal size or
independent.
 Space Complexity: Requires additional memory
for recursive stack space.