# How to Find Time Complexity of a Program in C

Analyzing the time complexity of a program involves understanding how the execution time of the program scales with the input size. Time complexity is usually expressed in Big O notation, which provides an upper bound on the number of basic operations performed by the program as a function of the input size. Here’s how you can find the time complexity of a program in C:

**Identify Basic Operations:**

- Break down your program into individual operations or steps that are considered “basic” or atomic.
- For example, assignments, comparisons, arithmetic operations, loops, and function calls are often considered basic operations.

**Count the Operations:**

- Count the number of basic operations performed in terms of the input size.
- For example, in a loop, if there are
`n`

iterations and each iteration performs a constant number of basic operations, the loop contributes`n`

basic operations to the overall count.

**Express in Big O Notation:**

- Express the number of basic operations as a function of the input size
`n`

. - Remove constant factors and lower-order terms from the expression.
- For example, if the number of operations is
`3n^2 + 5n + 10`

, the time complexity is O(n^2) since the quadratic term dominates.

**Analyze Nested Loops:**

- If your program has nested loops, analyze the time complexity of each loop independently.
- The time complexity of nested loops multiplies, so if you have an outer loop with
`n`

iterations and an inner loop with`m`

iterations, the total number of basic operations might be`O(n * m)`

.

**Choose Dominant Factor:**

- If your program contains different parts with varying time complexities, choose the one that dominates the overall time complexity.
- For example, if you have a loop with O(n^2) complexity and another part with O(n) complexity, the overall time complexity is O(n^2) since it’s the dominant factor.

**Consider Worst Case:**

- Analyze the worst-case scenario for your program. This gives an upper bound on the execution time.

**Recursive Algorithms:**

- For recursive algorithms, you might need to establish a recurrence relation and solve it to determine the time complexity. Techniques like the Master Theorem can be useful for this purpose.

**Compare to Common Time Complexities:**

- Familiarize yourself with common time complexities (e.g., O(1), O(log n), O(n), O(n log n), O(n^2), O(n^3), etc.) and compare your result to these to determine the growth rate.

It’s important to note that determining the exact time complexity can sometimes be complex, especially for more complex algorithms. In such cases, analyzing the algorithm’s performance using benchmarks and profiling tools can provide valuable insights.

Remember that the time complexity analysis gives you an understanding of how the program’s performance scales with input size. It doesn’t provide the actual execution time in seconds, but it helps you compare how different algorithms or implementations behave as the input grows.