# Order of Complexity in C

Order of Complexity is a term used in computer science to measure the efficiency of an algorithm or a program. It refers to the amount of time and resources required to solve a problem or perform a task. In programming, the Order of Complexity is usually expressed in terms of Big O notation, which gives an upper bound on the time or space requirements of an algorithm. In this article, we will discuss the Order of Complexity in the C programming language and its significance.

## Order of Complexity in C Programming Language:

In C programming, the Order of Complexity of an algorithm depends on the number of operations performed by the program. For example, if we have an array of size n and we want to search for a particular element in the array, the Order of Complexity of the algorithm will depend on the number of elements in the array. If we perform a Linear Search through the array, the Order of Complexity will be O(n), which means that the time taken to search for the element will increase linearly with the size of the array. If we use a Binary Search Algorithm instead, the Order of Complexity will be O(log n), which means that the time taken to search for the element will increase logarithmically with the size of the array.

Similarly, the Order of Complexity of other algorithms, such as Sorting Algorithms, Graph Algorithms, and Dynamic Programming Algorithms also depends on the number of operations the program performs. The Order of Complexity of these algorithms can be expressed using Big O notation.

Let's take a look at some common orders of complexity and their corresponding algorithms:

• O(1) - Constant Time Complexity:

This means that the algorithm takes a constant amount of time, regardless of the input size. For example, accessing an element in an array takes O(1) time, as the element can be accessed directly using its index.

• O(log n) - Logarithmic Time Complexity:

This means that the algorithm's time taken increases logarithmically with the input size. This is commonly seen in Divide-and-Conquer Algorithms like Binary Search, which divide the input into smaller parts to solve the problem.

• O(n) - Linear Time Complexity:

This means that the algorithm's time taken increases linearly with the input size. Examples of such algorithms are Linear Search and Bubble Sort.

• O(n log n) - Linearithmic Time Complexity:

This means that the algorithm's time taken increases by n multiplied by the logarithm of n. Examples of such algorithms are Quicksort and Mergesort.

• O(n^2) - Quadratic Time Complexity:

This means that the algorithm's time taken increases quadratically with the input size. Examples of such algorithms are Bubble Sort and Insertion Sort.

• O(2^n) - Exponential Time Complexity:

This means that the algorithm's time taken doubles with each increase in the input size. This is commonly seen in Recursive Algorithms like the Fibonacci Series.

It is important to know that the Order of Complexity only provides an upper bound on the time taken by the algorithm. The actual time taken may be much less than this bound, depending on the input data and the implementation of the algorithm.

In C programming, the Order of Complexity of an algorithm can be determined by analyzing the code and counting the number of operations performed. For example, if we have a loop that iterates through an array of size n, the time complexity of the loop will be O(n). Similarly, if we have a recursive function that calls itself k times, the time complexity of the function will be O(2^k).

To optimize the performance of a program, it is important to choose algorithms with a lower Order of Complexity. For example, if we need to sort an array, we should use a Sorting algorithm with a lower order of complexity, such as Quicksort or Mergesort, rather than Bubble Sort, which has a higher order of complexity.

### Analyzing Order of Complexity:

To analyze an algorithm's Order of Complexity, we need to determine how its running time or space usage grows as the input size increases. The most common method for doing this is to count the number of basic operations performed by the algorithm.

A basic operation is an operation that takes a constant amount of time to perform, such as adding two numbers or accessing an array element. By counting the number of basic operations performed by the algorithm as a function of the input size, we can determine its Order of Complexity.

For example, consider the following C function that calculates the sum of the first n integers:

C Code:

In this function, the loop runs n times, and each iteration performs a constant amount of work (adding i to the total). Therefore, the number of basic operations performed by this algorithm is proportional to n, and its time complexity is O(n).