space complexity time complexity n.
Skip this Video
Loading SlideShow in 5 Seconds..
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 36


  • Uploaded on

SPACE COMPLEXITY & TIME COMPLEXITY. ALGORITHMS COMPLEXITY. What Is An Algorithm??. An algorithm is a step-by-step procedure for solving a problem in a finite amount of time. Analysis of Algorithms or Performance Analysis.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'SPACE COMPLEXITY & TIME COMPLEXITY' - finn-frazier

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
what is an algorithm
What Is An Algorithm??
  • An algorithm is a step-by-step procedure for solving a problem in a finite amount of time.
analysis of algorithms or performance analysis
Analysis of Algorithms or Performance Analysis
  • Program performance is the amount of computer memory and time needed to run a program.
criteria for measurement
Criteria for Measurement

Two criteria are used to judge algorithms:

time complexity

space complexity.

Space Complexity of an algorithm is the amount of memory it needs to run to completion.

Time Complexity of an algorithm is the amount of CPU time it needs to run to completion.

space complexity
Space Complexity
  • Memory space S(P) needed by a program P, consists of two components:
    • A fixed part: needed for instruction space (byte code), simple variable space, constants space etc.  c
    • A variable part: dependent on a particular instance of input and output data.  Sp(instance)
  • S(P) = c + Sp(instance)
time complexity
Time Complexity
  • Time required T(P) to run a program P also consists of two components:
    • A fixed part: compile time which is independent of the problem instance  c.
    • A variable part: run time which depends on the problem instance  tp(instance)
  • T(P) = c + tp(instance)

int fun(int p, int q, int r)


return (p+q)/r*8+(p*r)*(p+q+r)-(p*q*r)+89;


  • Above function which is named as fun take p,q,r as an argument or input and return a output of a some simple arithmetic operations.
  • According to the classification given, this function has only fixed space requirements.

S fun(I)=0

  • Therefore,

[S fun(I) is a variable space requirement]

  • Therefore, space complexity of simple arithmetic function is only equal to fixed space requirement.

int sum(int array[ ],int n)


int i , temp=0;

for (i=0 ; i<n ; i++)


temp=temp + array[i];


return temp;



In above function, we want to add a numbers although the output is simple but for input values we need a array.

  • Therefore, variable space requirement depends upon the programming languages. Different programming languages have different array passing method :
  • 1.Pascal like programming languages pass array by value . So in Pascal language, variable space requirement is,

S sum(I)=S sum(n)

where n is the size of an array.

2. In C language, it passes array by it’s base address(address of first element). C does not copy the array. Therefore,

where n is size of array.

S sum(n)=0


Following function also adds a list of number but in that particular function summation is handled recursively.

  • This means that compiler must save the parameter, local variable and return address for recursive call.

/* Recursive function for summing list of number */

float rsum (float list [ ], int n)



return rsum (list , n-1 )+ list[n-1];

return 0;



Space for given example needed for one recursive call is number of bytes required for parameter and return address.

  • We can find the sizeof operator to find the number of bytes by each type.
  • Following table show the number of bytes required for one recursive call

The time T(P) taken by a program P, is the sum of its compile time and its run time.

  • The compile time is similar to the fixed space component since it does not depend upon instance characteristics.
  • The program execution time is denoted by Tp.
  • To determine Tp we require a detailed knowledge of compiler’s attributes. That is we must know how the compiler translates our source program into object code.

Here for ex. we have a simple program that adds and subtracts numbers. Let n denote the instance characteristics, then

Tp(n)=Ca ADD(n)+Cs SUB(n)+Cl LDA(n)+Cst STA (n)


Ca, Cs, Cl, Cst are the constants that refer the time needed to perform each operation and ADD, SUB, LDA, STA are the number of operations performed when program is run with instance characteristics n.


A program is syntactically or semantically meaningful program segment whose execution time is independent of instance characteristics.

Here, we want to obtain step count for sum function in iterative function. We have to count only executable statements. Following code shows where to place the count statements

float sum(float list[ ], int n)


float tempsum =0;

count++; /*f or assignment*/


int i;

for(i=0; i<n; i++)


count++; /*For for loop*/

tempsum+= list[ ];

count++; /*for assignment*/


count++; /*last execution*/

count++; /* for return */

return tempsum;



In above code, count variable is initialized to 0 initially. Then its final value will be,


  • So, each invocation of sum executes a total of 2n+3 steps.
  • Now, we will construct a table, which is step count table. We will first enter steps for statement. Next figure out the frequency and then the total steps and then final step count.

/* recursive function without count statements */

float rsum (float list [ ] ,int n)


if (n)

return rsum (list,n-1)+ list [n-1] ;

return 0 ;



/* recursive function with count statements added*/

float rsum (float list [ ] ,int n)


count++ ; // for if conditional

if (n)

count++ ; // for return & rsum invocation

return rsum (list,n-1) + list [n-1] ;


count++ ;

return list [0] ;




  • For the boundary condition of n=0 :-

Only if conditional statement & second return statement are executed .

So the total step count for n=0 is 2.

  • For n>0 :-

The if conditional statement & the first return statement are executed .

So each recursive call with n>0 adds two to the step count.



  • So the step count for the function is
  • With the help of the following table we can also prove the recursive summing function .


  • The recursive function has lower step count then its iterative counterpart.
  • Recursive function typically run slower than the iterative version & takes more time than those of the iterative function.
  • Recursive function also uses more memory space for its each call.
  • For space complexity, iterative function is better than recursive function.
  • For time complexity , recursive function is better than iterative function.