\n
Introduction
\n
\n
\n Finding out time complexity of your code helps you to develop\n better programs that run faster. Some programs are easy to\n analyze, but when we have loops, nested functions or\n recursion; the situation gets tricky.\n
\n
\n The time complexity can be determined by analyzing the\n program's statements going line by line. The most common\n metric used to analyze time complexity is Big O Notation.\n
\n
\n Big O notation cares about the worst case scenario. For ex: in\n linear search of an array of N elements, searching for the\n last element is the worst case scenario which will take O(N)\n time.
\n Big O = Big Order Function(Drop the lower order and constant\n terms). For ex: O(7n3-n2+5) =\n O(n3).\n
\n
\n If we plot the most common Big O Notations, we would get the\n graph:\n
\n
\n
\n \n ![\"Big](\"/static/80147a148e3065372a89cc6f688a5ce3/fcda8/bigO.png\" "\\"Big")
\n \n
\n
\n Let’s take a look, how to translate code into time complexity.\n
\n
\n
\n
Sequential Statements
\n
\n
\n If we have n statements performing basic operations such as\n assignment, reading a variable or comparision then we can\n assume the time complexity for each statement is O(1).\n
\n
\n T(n) = t(statement1) + t(statement2) + ... + t(statementN).\n
\n
\n If each statement executes a basic operation then we can say\n it takes constant time i.e. O(1), be it 1 or 100 lines of\n statements(executing basic operation).\n
\n
\n Cosider a C++ program to multiply two integers.
\n \n int a=10;
\n int b=5;
\n int mul=a*b;
\n cout<< "Product: " << mul;\n \n
\n These statements are basic operations and each of them will\n take O(1) time. So summing up, the time complexity will still\n remain O(1) and not 4*O(1).\n
\n
\n
\n
Conditional Statements
\n
\n
\n \n if (condition) {
\n statement1;
\n statement2;
\n } else {
\n statement3;
\n }\n \n
\n
\n The time complexity of this would be:
\n T(n) = MAX of ([t(statement1) + t(statement2)],\n [t(statement3)])\n
\n
\n For ex: Suppose statement1 takes O(nlogn), statement2 takes\n O(n) and the condition is happened to be true then time\n complexity would be O(max of [nlogn,n]) = O(nlogn).\n
\n
\n
\n
Looping Statements
\n
\n
Constant time loops:
\n
\n If the loop bounds a constant number then the time complexity\n would also be constant time i.e. O(1).\n
\n
\n \n for (int i = 0; i < 10; i++) {
\n cout << i;
\n }
\n \n That code is O(1) because it no longer depends on the input\n size. It will always run the statement ten times.\n
\n
\n
\n
Linear time loops:
\n
\n For any loop, we find out the runtime of the block inside them\n and multiply it by the number of times the program will repeat\n the loop.\n
\n
\n \n for (int i = 0; i < N; i++) {
\n statement1;
\n statement2;
\n }\n \n
\n
\n For this, the loop will execute the block N(input) times and\n thus we get the time complexity:\n
\n
\n T(n) = n * [ t(statement1) + t(statement2) ]\n
\n
\n
\n
Logarithmic time loops
\n
\n An algorithm is O(logn) if it takes a constant time to cut the\n problem size by a fraction.\n
\n
\n Consider the following loop where the iterator is doubled\n after every loop.
\n \n for(int i = 1; i <= N; i *= 2 ) {
\n cout << i;
\n }\n \n
\n
\n If we observe carefully, the value of i is doubling every\n time. Initially i = 1, and in subsequent steps i = 2,4,8 and\n so on. Let us assume that the loop is executing some k times.\n At kth step 2k = n, and at (k + 1)th step we come\n out of the loop. Taking logarithm on both sides, gives\n
\n
\n log(2k) = log(n)
\n klog2 = logn
\n k = logn
\n //Assume the base=2\n
\n
\n
\n
Nested Loops
\n
\n Sometimes you will have problems related to 2D arrays then you\n will have to use 2 loops to visit all the array elements.\n
\n \n for (let i = 0; i < n; i++) {
\n statement1;
\n for (let j = 0; j < m; j++) {
\n statement2;
\n }
\n }\n \n
\n
\n Then the time complexity would be O(n*m). If you had n instead\n of m then it would have been O(n2).\n
\n
\n T(n) = n * [t(statement1) + m * t(statement2)]\n
\n
\n
\n
Function Calls
\n
\n \n for (let i = 0; i < n; i++) {
\n function1();
\n for (let j = 0; j < n; j++) {
\n function2();
\n for (let k = 0; k < n; k++) {
\n function3();
\n }
\n }
\n }
\n \n
\n
\n Depending on the runtime of each function, we will get\n different time complexities.\n
\n If they are all constants, O(1) then final runtime would be\n O(n3).
\n Suppose function1, function2 are constant and function3 has\n O(n2) runtime then this program will have an\n overall runtime of O(n5).\n
\n
\n In general,
\n T(n) = n * [ t(fn1()) + n * [ t(fn2()) + n * [ t(fn3()) ] ] ]\n
\n
\n
\n
Recursive Calls
\n
\n
\n Analyzing the runtime of recursive functions might get a\n little tricky. There are different ways to do it. One\n intuitive way is to explore the recursion tree.\n
\n
\n \n function fn(n) {
\n if (n < 0) return 0;
\n if (n < 2) return n;
\n return fn(n - 1) + fn(n - 2);
\n }\n \n
\n
Let's see how many calls will be made:
\n
\n - \n If n=2, then you will have 3 calls i.e fn(2) which calls\n fn(1) & fn(0).\n
\n - \n If n=3, then you will have 5 calls ie. fn(3) which calls\n fn(2)(which again calls fn(1) and fn(0)) and fn(1).\n
\n
\n
\n The total no. of calls atmost can be 2n in worst\n case. So the time complexity would be O(2n) in this\n example.\n
\n
\n
\n
Introduction
\n
\n
\n Finding out time complexity of your code helps you to develop\n better programs that run faster. Some programs are easy to\n analyze, but when we have loops, nested functions or\n recursion; the situation gets tricky.\n
\n
\n The time complexity can be determined by analyzing the\n program's statements going line by line. The most common\n metric used to analyze time complexity is Big O Notation.\n
\n
\n Big O notation cares about the worst case scenario. For ex: in\n linear search of an array of N elements, searching for the\n last element is the worst case scenario which will take O(N)\n time.
\n Big O = Big Order Function(Drop the lower order and constant\n terms). For ex: O(7n3-n2+5) =\n O(n3).\n
\n
\n If we plot the most common Big O Notations, we would get the\n graph:\n
\n
\n
\n \n \n \n
\n
\n Let’s take a look, how to translate code into time complexity.\n
\n
\n
\n
Sequential Statements
\n
\n
\n If we have n statements performing basic operations such as\n assignment, reading a variable or comparision then we can\n assume the time complexity for each statement is O(1).\n
\n
\n T(n) = t(statement1) + t(statement2) + ... + t(statementN).\n
\n
\n If each statement executes a basic operation then we can say\n it takes constant time i.e. O(1), be it 1 or 100 lines of\n statements(executing basic operation).\n
\n
\n Cosider a C++ program to multiply two integers.
\n \n int a=10;
\n int b=5;
\n int mul=a*b;
\n cout<< "Product: " << mul;\n \n
\n These statements are basic operations and each of them will\n take O(1) time. So summing up, the time complexity will still\n remain O(1) and not 4*O(1).\n
\n
\n
\n
Conditional Statements
\n
\n
\n \n if (condition) {
\n statement1;
\n statement2;
\n } else {
\n statement3;
\n }\n \n
\n
\n The time complexity of this would be:
\n T(n) = MAX of ([t(statement1) + t(statement2)],\n [t(statement3)])\n
\n
\n For ex: Suppose statement1 takes O(nlogn), statement2 takes\n O(n) and the condition is happened to be true then time\n complexity would be O(max of [nlogn,n]) = O(nlogn).\n
\n
\n
\n
Looping Statements
\n
\n
Constant time loops:
\n
\n If the loop bounds a constant number then the time complexity\n would also be constant time i.e. O(1).\n
\n
\n \n for (int i = 0; i < 10; i++) {
\n cout << i;
\n }
\n \n That code is O(1) because it no longer depends on the input\n size. It will always run the statement ten times.\n
\n
\n
\n
Linear time loops:
\n
\n For any loop, we find out the runtime of the block inside them\n and multiply it by the number of times the program will repeat\n the loop.\n
\n
\n \n for (int i = 0; i < N; i++) {
\n statement1;
\n statement2;
\n }\n \n
\n
\n For this, the loop will execute the block N(input) times and\n thus we get the time complexity:\n
\n
\n T(n) = n * [ t(statement1) + t(statement2) ]\n
\n
\n
\n
Logarithmic time loops
\n
\n An algorithm is O(logn) if it takes a constant time to cut the\n problem size by a fraction.\n
\n
\n Consider the following loop where the iterator is doubled\n after every loop.
\n \n for(int i = 1; i <= N; i *= 2 ) {
\n cout << i;
\n }\n \n
\n
\n If we observe carefully, the value of i is doubling every\n time. Initially i = 1, and in subsequent steps i = 2,4,8 and\n so on. Let us assume that the loop is executing some k times.\n At kth step 2k = n, and at (k + 1)th step we come\n out of the loop. Taking logarithm on both sides, gives\n
\n
\n log(2k) = log(n)
\n klog2 = logn
\n k = logn
\n //Assume the base=2\n
\n
\n
\n
Nested Loops
\n
\n Sometimes you will have problems related to 2D arrays then you\n will have to use 2 loops to visit all the array elements.\n
\n \n for (let i = 0; i < n; i++) {
\n statement1;
\n for (let j = 0; j < m; j++) {
\n statement2;
\n }
\n }\n \n
\n
\n Then the time complexity would be O(n*m). If you had n instead\n of m then it would have been O(n2).\n
\n
\n T(n) = n * [t(statement1) + m * t(statement2)]\n
\n
\n
\n
Function Calls
\n
\n \n for (let i = 0; i < n; i++) {
\n function1();
\n for (let j = 0; j < n; j++) {
\n function2();
\n for (let k = 0; k < n; k++) {
\n function3();
\n }
\n }
\n }
\n \n
\n
\n Depending on the runtime of each function, we will get\n different time complexities.\n
\n If they are all constants, O(1) then final runtime would be\n O(n3).
\n Suppose function1, function2 are constant and function3 has\n O(n2) runtime then this program will have an\n overall runtime of O(n5).\n
\n
\n In general,
\n T(n) = n * [ t(fn1()) + n * [ t(fn2()) + n * [ t(fn3()) ] ] ]\n
\n
\n
\n
Recursive Calls
\n
\n
\n Analyzing the runtime of recursive functions might get a\n little tricky. There are different ways to do it. One\n intuitive way is to explore the recursion tree.\n
\n
\n \n function fn(n) {
\n if (n < 0) return 0;
\n if (n < 2) return n;
\n return fn(n - 1) + fn(n - 2);
\n }\n \n
\n
Let's see how many calls will be made:
\n
\n - \n If n=2, then you will have 3 calls i.e fn(2) which calls\n fn(1) & fn(0).\n
\n - \n If n=3, then you will have 5 calls ie. fn(3) which calls\n fn(2)(which again calls fn(1) and fn(0)) and fn(1).\n
\n
\n
\n The total no. of calls atmost can be 2n in worst\n case. So the time complexity would be O(2n) in this\n example.\n
\n
\n