![Example 4
#include <stdio.h>
int main()
{
int n, i, sum = 0;
scanf("%d", &n);
int arr[n];
for(i = 0; i < n; i++)
{
scanf("%d", &arr[i]); sum = sum + arr[i];
}
printf("%d", sum);
}
Space Complexity:
• The array consists of n integer
elements.
• So, the space occupied by the array is 4
* n. Also we have integer variables
such as n, i and sum. Assuming 4 bytes
for each variable, the total space
occupied by the program is 4n + 12
bytes.
• Since the highest order of n in the
equation 4n + 12 is n, so the space
complexity is O(n) or linear.](https://image.slidesharecdn.com/6-240111114029-a3cbb372/85/Data-Structure-Algorithms-Mathematical-35-320.jpg)
![int sum(int A[], int n)
{
int sum = 0, i;
for(i = 0; i < n; i++)
sum = sum + A[i];
return sum;
}
• In above calculation
Cost is the amount of computer time required for a single operation in each line.
• Repetition is the amount of computer time required by each operation for all its repetitions.
• Total is the amount of computer time required by each operation to execute.
So above code requires '4n+4' Units of computer time to complete the task. Here the exact time is
not fixed. And it changes based on the n value. If we increase the n value then the time required also
increases linearly.
Totally it takes '4n+4' units of time to complete its execution
Example 2](https://image.slidesharecdn.com/6-240111114029-a3cbb372/85/Data-Structure-Algorithms-Mathematical-41-320.jpg)
Data Structure & Algorithms - Mathematical
- 2. 1. Floor and Ceiling Functions
- 3. 2. Remainder Function (Modular Arithmetic)
- 4. 3. Integer and Absolute Value Functions
- 5. 4. Summation Symbol (Sums)
- 8. 7. Exponents and Logarithms
- 9. ASYMPTOTIC NOTATIONS BIG O, OMEGA
- 10. Asymptotic Analysis • The time required by an algorithm falls under three types − • Best Case − Minimum time required for program execution. • Average Case − Average time required for program execution. • Worst Case − Maximum time required for program execution. 10
- 11. Asymptotic Analysis (Cont..) • Asymptotic analysis of an algorithm refers to defining the mathematical boundation/framing of its run-time performance. • Derive the best case, average case, and worst case scenario of an algorithm. • Asymptotic analysis is input bound. • Specify the behaviour of the algorithm when the input size increases •Theory of approximation. •Asymptote of a curve is a line that closely approximates a curve but does not touch the curve at any point of time. 11
- 12. Asymptotic notations • Asymptotic notations are mathematical tools to represent the time complexity of algorithms for asymptotic analysis. • Asymptotic order is concerned with how the running time of an algorithm increases with the size of the input, if input increases from small value to large values 1. Big-Oh notation (O) 2. Big-Omega notation (Ω) 3. Theta notation (θ) 4. Little-oh notation (o) 5. Little-omega notation (ω) 12 9/11/21
- 13. Big-Oh Notation (O) • Big-oh notation is used to define the worst-case running time of an algorithm and concerned with large values of n. • Definition: A function t(n) is said to be in O(g(n)), denoted as t(n) ϵ O(g(n)), if t(n) is bounded above by some constant multiple of g(n) for all large n. i.e., if there exist some positive constant c and some non-negative integer n0 such that t(n) ≤ cg(n) for all n ≥ n0 • O(g(n)): Class of functions t(n) that grow no faster than g(n). • Big-oh puts asymptotic upper bound on a function. 9/11/21 13
- 14. Big-Oh Notation (O) 9/11/21 14
- 15. Big-Oh Notation (O) 1 < log n < √n < n < n logn < n2 < n3 < ……………< 2n < 3n < …. <nn • Let t(n) = 2n + 3 upper bound 2n + 3 ≤ _____?? 2n + 3 ≤ 5n n ≥ 1 here c = 5 and g(n) = n t(n) = O(n) 2n + 3 ≤ 5n2 n ≥ 1 here c = 5 and g(n) = n2 t(n) = O(n2 ) 15
- 16. Big-Omega notation (Ω) • This notation is used to describe the best case running time of algorithms and concerned with large values of n. • Definition: A function t(n) is said to be in Ω(g(n)), denoted as t(n) ϵ Ω(g(n)), if t(n) is bounded below by some positive constant multiple of g(n) for all large n. i.e., there exist some positive constant c and some non-negative integer n0. Such that t(n) ≥cg(n) for all n ≥ n0 • It represents the lower bound of the resources required to solve a problem. 9/11/21 16
- 18. Big-Omega notation (Ω) 1 < log n < √n < n < n logn < n2 < n3 < ……………< 2n < 3n < …. <nn • Let t(n) = 2n + 3 lower bound 2n + 3 ≥ _____?? 2n + 3 ≥ 1n n ≥ 1 here c = 1 and g(n) = n t(n) = Ω(n) 2n + 3 ≥ 1log n n ≥ 1 here c = 1 and g(n) = log n t(n) = Ω(log n) 9/11/21 18
- 19. Asymptotic Analysis of Insertion sort •Time Complexity: •Best Case: the best case occurs if the array is already sorted, tj=1 for j=2,3…n. •Linear running time: O(n) 9/11/21 19
- 20. Asymptotic Analysis of Insertion sort •Worst case : If the array is in reverse sorted order •Quadratic Running time. O(n2) 9/11/21 20
- 21. Properties of O, Ω and θ General property: If t(n) is O(g(n)) then a * t(n) is O(g(n)). Similar for Ω and θ Transitive Property : If f (n) ϵ O(g(n)) and g(n) ϵ O(h(n)), then f (n) ϵ O(h(n)); that is O is transitive. Also Ω, θ, o and ω are transitive. Reflexive Property If f(n) is given then f(n) is O(f(n)) Symmetric Property If f(n) is θ(g(n)) then g(n) is θ(f(n)) Transpose Property If f(n) = O(g(n)) then g(n) is Ω(f(n)) 9/11/21 21
- 22. Review Questions • Indicate constant time complexity in terms of Big-O notation. A. O(n) B. O(1) C. O(logn) D. O(n^2) • Big oh notation is used to describe __________ • Big O Notation is a _________function used in computer science to describe an ____________ • Big Omega notation (Ω) provides _________bound. • Given T1(n) =O(f(n)) and T2(n)=O(g(n).Find T1(n).T2(n) 22
- 24. Asymptotic Notation – THETA Θ
- 25. Example - THETA •Show that n2 /2 – 2n = Θ(n2 ).
- 26. Example - THETA
- 29. Review Questions 1. Give examples of functions that are in Θ notation as well as functions that are not in Θ notation. 2. Which function gives the positive value of the given input? 3. K (mod) M gives the reminder of ____ divided by ____ 4. For a given set of number n, the number of possible permutation will be equal to the ____________ value of n. 5. ________Notation is used to specify both the lower bound and upper bound of the function.
- 30. COMPLEXITY – TIME , SPACE TRADE OFF
- 31. SPACE COMPLEXITY • Space complexity is the total amount of memory space used by an algorithm/program including the space of input values for execution. So to find space-complexity, it is enough to calculate the space occupied by the variables used in an algorithm/program. • Space complexity S(P) of any algorithm P is, • S(P) = C + SP(I) • Where C is the fixed part and S(I) is the variable part of the algorithm which depends on instance characteristic I. Example: Algorithm: SUM(A, B) Step 1 - START Step 2 - C ← A + B + 10 Step 3 – Stop Here we have three variables A, B & C and one constant. Hence S(P) = 1+3. Space requirement depends on data types of given variables & constants. The number will be multiplied accordingly.
- 32. How to calculate Space Complexity of an Algorithm? • In the Example program, 3 integer variables are used. • The size of the integer data type is 2 or 4 bytes which depends on the architecture of the system (compiler). Let us assume the size as 4 bytes. • The total space required to store the data used in the example program is 4 * 3 = 12, Since no additional variables are used, no extra space is required. Hence, space complexity for the example program is O(1), or constant.
- 33. EXAMPLE 2 • In the code given above, the array stores a maximum of n integer elements. Hence, the space occupied by the array is 4 * n. Also we have integer variables such as n, i and sum. • Assuming 4 bytes for each variable, the total space occupied by the program is 4n + 12 bytes. • Since the highest order of n in the equation 4n + 12 is n, so the space complexity is O(n) or linear.
- 34. EXAMPLE 3 #include<stdio.h> int main() { int a = 5, b = 5, c; c = a + b; printf("%d", c); } Space Complexity: size(a)+size(b)+size(c) =>let sizeof(int)=2 bytes=>2+2+2=6 bytes =>O(1) or constant
- 35. Example 4 #include <stdio.h> int main() { int n, i, sum = 0; scanf("%d", &n); int arr[n]; for(i = 0; i < n; i++) { scanf("%d", &arr[i]); sum = sum + arr[i]; } printf("%d", sum); } Space Complexity: • The array consists of n integer elements. • So, the space occupied by the array is 4 * n. Also we have integer variables such as n, i and sum. Assuming 4 bytes for each variable, the total space occupied by the program is 4n + 12 bytes. • Since the highest order of n in the equation 4n + 12 is n, so the space complexity is O(n) or linear.
- 36. • Time Complexity of an algorithm represents the amount of time required by the algorithm to run to completion. • Time requirements can be defined as a numerical function T(n), where T(n) can be measured as the number of steps, provided each step consumes constant time. • Eg. Addition of two n-bit integers takes n steps. • Total computational time is T(n) = c*n, • where c is the time taken for addition of two bits. • Here, we observe that T(n) grows linearly as input size increases. Time Complexity
- 37. Time Complexity (Cont..) Two methods to find the time complexity for an algorithm 1. Count variable method 2. Table method 9/11/21 37
- 39. Table Method • The table contains s/e and frequency. • The s/e of a statement is the amount by which the count changes as a result of the execution of that statement. • Frequency is defined as the total number of times each statement is executed. • Combining these two, the step count for the entire algorithm is obtained. 39 9/11/21
- 41. int sum(int A[], int n) { int sum = 0, i; for(i = 0; i < n; i++) sum = sum + A[i]; return sum; } • In above calculation Cost is the amount of computer time required for a single operation in each line. • Repetition is the amount of computer time required by each operation for all its repetitions. • Total is the amount of computer time required by each operation to execute. So above code requires '4n+4' Units of computer time to complete the task. Here the exact time is not fixed. And it changes based on the n value. If we increase the n value then the time required also increases linearly. Totally it takes '4n+4' units of time to complete its execution Example 2
- 42. Example 3 Consider the following piece of code... int sum(int a, int b) { return a+b; } In the above sample code, it requires 1 unit of time to calculate a+b and 1 unit of time to return the value. That means, totally it takes 2 units of time to complete its execution. And it does not change based on the input values of a and b. That means for all input values, it requires the same amount of time i.e. 2 units. If any program requires a fixed amount of time for all input values then its time complexity is said to be Constant Time Complexity
- 43. Cost Times i = 1; c1 1 sum = 0; c2 1 whil e (i <= n) { c3 n+1 i = i + 1; c4 n sum = sum + i; c5 n } 3n+3 Total Cost = c1 + c2 + (n+1)*c3 + n*c4 + n*c5 The time required for this algorithm is proportional to n Example 4
- 44. Total Cost = c1 + c2 + (n+1)*c3 + n*c4 + n*(n+1)*c5+n*n*c6+n*n*c7+n*c8 The time required for this algorithm is proportional to n2 Example 5
- 45. INSERTION SORT -TIME COMPLEXITY
- 47. Time Complexity of Bubble Sort
- 48. Review Questions Sort the following numbers using bubble sort and Insertion sort •35,12,14,9,15,45,32,95,40,5 •3, 1, 4, 1, 5, 9, 2, 6, 5 •17 14 34 26 38 7 28 32 •35,12,14,9,15,45,32,95,40,5
- 49. Review questions 49 1. Calculate the time complexity for the below algorithms using table method
- 50. 50 2. 3. 9/11/21