## Time and Space Complexity

Time and space complexity are two important concepts in computer science that are used to measure the efficiency and performance of algorithms. TC refers to the amount of time taken by an algorithm to complete its execution, whereas SC refers to the amount of memory required by an algorithm to solve a problem.

## Asymptotic Notation

Asymptotic notation is a mathematical notation used to describe the behavior of a function as the input size grows to infinity. It is important because it helps us to analyze the efficiency and performance of algorithms without actually implementing them on a computer. Asymptotic notation includes three commonly used notations: Big-O, Big-Ω, and Big-θ.

**Big-O notation (O)** is used to represent the upper bound of an algorithm’s time or space complexity. It gives us an idea of how an algorithm’s time or space requirements grow as the size of the input increases. For example, if an algorithm’s time complexity is O(n), it means that the algorithm’s time requirements increase linearly with the size of the input.

**Big-Ω notation (Ω)** is used to represent the lower bound of an algorithm’s time or space complexity. It gives us an idea of the best-case scenario for an algorithm’s time or space requirements. For example, if an algorithm’s time complexity is Ω(n), it means that the algorithm’s time requirements will not be worse than linear, even in the worst-case scenario.

**Big-θ notation (θ)** is used to represent both the upper and lower bounds of an algorithm’s time or space complexity. It gives us an idea of the tightest possible bound for an algorithm’s time or space requirements. For example, if an algorithm’s time complexity is θ(n), it means that the algorithm’s time requirements will grow linearly with the size of the input, and there will be no better or worse-case scenarios.

## By Example

Let’s take the example of two sorting algorithms, bubble sort and quicksort, to understand the concept of time complexity and asymptotic notation. Bubble sort has a time complexity of O(n^2) and a space complexity of O(1), which means that its time requirements increase quadratically with the size of the input, and it requires a constant amount of memory to solve the problem. On the other hand, quicksort has a time complexity of O(nlogn) and a space complexity of O(logn), which means that its time requirements increase logarithmically with the size of the input, and it requires a logarithmic amount of memory to solve the problem.

## Compare

The time complexity of both algorithms, we can see that quicksort is much more efficient than bubble sort for large input sizes. This is because bubble sort has a quadratic time complexity, which means that its time requirements will increase rapidly as the input size grows, whereas quicksort has a logarithmic time complexity, which means that its time requirements will increase at a much slower rate. Asymptotic notation helps us to analyze the efficiency and performance of algorithms like these and choose the best algorithm for a given problem based on its time and space requirements.

- Q-1.
- What do you understand by time and space complexity? What is asymptotic notation? Why it is important? Discuss using suitable example.
- Q-2.
- What is recurrence? Discuss in detail the master method for solving a recurrence.
- Q-3
- What is a Travelling Salesman problem? Discuss the greedy algorithm for solving the Travelling Salesman Problem.
- Q-4
- What do you understand by height balanced tree? What is a splay tree? Discuss the insertion/deletion operation on splay tree.
- Q-5
- What is Minimum Spanning Tree? Discuss the Steps for finding Minimum Spanning Tree using Kruskal’s Algorithm.
- Q-6
- What is a Graph? Discuss the depth first traversal of a graph and its computational complexity. Also discuss the topological sort using depth first traversal.
- Q-7
- What is a flow network? Explain Ford-Fulkerson Algorithm for Maximum Flow Problem.
- Q-8
- What is bitonic sequence? What is merging network? Explain.