The time complexity of algorithms means the time it takes for an algorithm to run as being a function of the same length as the input. In this article, I will introduce you to the concept of time complexity of algorithms and its examples by using the C ++ programming language.

## What is Time Complexity of Algorithms?

Time complexity makes it easier to estimate how long a program will run. Accurately calculating the runtime of a program is a very laborious process. Time complexity means the maximum number of primitive operations that a program can take to execute, where the regular operations are one-time additions, multiplications, assignments, etc.

**Also, Read – Machine Learning Full Course for free.**

When calculating the time complexity of a program, we can leave certain operations unaccounted for and focus on those that are performed the most times. These operations are qualified as dominant.

The number of dominant operations depends on the specific input data. We generally want to know how the execution time depends on a particular aspect of the data. Most often this is the size of the data, but it can also be the size of a square matrix or the value of an input variable.

## Types of Time Complexity Using C++ Programming Language

Now, in this section, I will take you through different types of Time Complexities with the implementation of the C++ programming language.

**Linear: O(n)**:

**Quadratic: O(n²):**

**Linear Time O(n+m):**

**Time Complexity O(n*m):**

**Logarithmic Time O(log n):**

## Space Complexity

The space complexity of an algorithm quantifies the time it takes for a program to run as a function of the length of the input. It is directly proportional to the more memory that your program acquires at any instance during execution. For example, int consumes 4 bytes of memory.

Specifically, the space complexity is the amount of memory required to perform the calculation. It includes all variables, both global and local, dynamic pointer data structures, and, in case of recursion, the contents of the stack.

Depending on the convention, input data can also be included. Space complexity is more difficult to calculate than time complexity of algorithms because all of these variables and data structures are not necessarily needed at the same time. Global variables exist and occupy memory all the time; local variables will only exist when the function is called.

I hope you liked this article on the concept of Time Complexity of algorithms with the implementation of C++ programming language. Feel free to ask your valuable questions in the comments section below.