Chapter Two

Algorithm Analysis
Concepts
 What is an algorithm Analysis?

 Algorithm analysis refers to the

process of determining how much
computing time and storage that
algorithms will require.
 In other words, it’s a process of
redacting the resource requirement
of algorithms in a given environment.
2
What is an algorithm Analysis? ………..
 In order to solve a problem, there are
many possible algorithms.

 One has to be able to choose the best

algorithm for the problem at hand
using some scientific method.

 To classify some data structures and

algorithms as good:
 we need precise ways of analyzing them in

terms of resource requirement.

3
 The main resources are:
• Running Time

• Memory Usage

• Communication Bandwidth

Note: Running time is the most important

since computational time is the most
precious resource in most problem
domains.
4
 There are two approaches to measure the
efficiency of algorithms:
1. Empirical
 based on the total running time of the

program.
 Uses actual system clock time.

Example:
t1
for(int i=0; i<=10; i++)
cout<<i;
t2
Running time taken by the above algorithm
(TotalTime) = t2-t1;
5
 It is difficult to determine efficiency of
algorithms using this approach,
 Because clock-time can vary based on
many factors. For example:
a) Processor speed of the
computer
1.78GHz 2.12GHz
10s <10s

b) Current processor load

 Only the work 10s
 With printing 15s
6

 With printing & browsing the internet >15s

c) Specific data for a particular
run of the program
Input size
Input properties
t1
for(int i=0; i<=n; i++)
cout<<i;
t2
T=t2-t1;
For n=100, T>=0.5s
n=1000, T>0.5s 7
d) Operating System
 Multitasking Vs Single tasking
 Internal structure

8
2. Theoretical
 Determining the quantity of resources
required using mathematical concept.

 Analyze an algorithm according to the

number of basic operations (time
units) required, rather than according
to an absolute amount of time involved.
9
 We use theoretical approach to
determine
the efficiency of algorithm because:

• The number of operation will not vary

under
different conditions.

• It helps us to have a meaningful measure

that
permits comparison of algorithms
independent
of operating platform.

• It helps to determine the complexity of

10

algorithm.
Complexity Analysis
 Complexity Analysis is the systematic study
of the cost of computation, measured either
in:

Time units
 Operations performed, or
The amount of storage space required.

11
 Two important ways to characterize the
effectiveness of an algorithm are its Space
Complexity and Time Complexity.
 Time Complexity: Determine the approximate
amount of time (number of operations) required to
solve a problem of size n.
 The limiting behavior of time complexity as
size increases is called the Asymptotic Time
Complexity.
 Space Complexity: Determine the approximate
memory required to solve a problem of size n.
 The limiting behavior of space complexity as
size increases is called the Asymptotic
Space Complexity.
12
 Asymptotic Complexity of an algorithm determines
the size of problems that can be solved by the
algorithm.
 Factors affecting the running time of a program:
 CPU type (80286, 80386, 80486, Pentium I---IV)
 Memory used
 Computer used
 Programming Language
 C (fastest), C++ (faster), Java (fast)
 C is relatively faster than Java, because C is relatively nearer to Machine language,
so, Java takes relatively larger amount of time for interpreting/translation to machine
code.

 Algorithm used
 Input size
Note: Important factors for this course are Input size 13and Algorithm
used.
 Complexity analysis involves two distinct phases:
• Algorithm Analysis: Analysis of the
algorithm or data structure to produce a
function T(n) that describes the algorithm in
terms of the operations performed in order to
measure the complexity of the algorithm.
Example: Suppose we have hardware capable of
executing 106 instructions per second. How long
would it take to execute an algorithm whose
complexity function is T(n)=2n2 on an input size of
n=108?
Solution: T(n)= 2n2=2(108)2 = 2*1016
Running time=T(108)/106=2*1016/106=2*1010
seconds.
• Order of Magnitude Analysis: Analysis of
the function T (n) to determine the general
complexity category to which it belongs. 14
 There is no generally accepted set of
rules for algorithm analysis.
 However, an exact count of operations
is commonly used.
 To count the number of operations we
can use the following Analysis Rule.

Analysis Rules:
1. Assume an arbitrary time unit.
2. Execution of one of the following
operations
takes time 1 unit:
 Assignment Operation
Example: i=0;
 Single Input/Output Operation
Example: cin>>a; 15

cout<<“hello”;
  Single Boolean Operations

Example: i>=10

 Single Arithmetic Operations

Example: a+b;

 Function Return

Example: return sum;

3. Running time of a selection statement (if,

switch) is the time for the condition evaluation
plus the maximum of the running times for the
individual clauses in the selection.
16
Example: int x;
int sum=0;
if(a>b)
{
sum= a+b;
cout<<sum;
}
else
{
cout<<b;
}
T(n) = 1+1+max(3,1)
=5 17
4. Loop statements:
• The running time for the statements
inside the loop * number of iterations +
time for setup(1) + time for checking
(number of iteration + 1) + time for
update (number of iteration)
• The total running time of statements
inside a group of nested loops is the
running time of the statements * the
product of the sizes of all the loops.
• For nested loops, analyze inside out.
• Always assume that the loop executes
the maximum number of iterations
possible. (Why?)
 Because we are interested in the worst case complexity.

18
5. Function call:
• 1 for setup + the time for any
parameter calculations + the time
required for the execution of the
function body.
Examples:
1)
int k=0,n;
cout<<“Enter an integer”;
cin>>n
for(int i=0;i<n; i++)
k++;

T(n)= 3+1+n+1+n+n=3n+5
19
2)
int i=0;
while(i<n)
{
cout<<i;
i++;
}
int j=1;
while(j<=10)
{
cout<<j;
j++;
}
T(n)=1+n+1+n+n+1+11+2(10)
= 3n+34 20
3)
int k=0;
for(int i=1 ; i<=n; i++)
for( int j=1; j<=n; j++)
k++;

T(n)=1+1+(n+1)+n+n(1+(n+1)+n+n)
= 2n+3+n(3n+2)
= 2n+3+3n2+2n
= 3n2+4n+3
21
4). int sum=0;
for(i=1;i<=n;i++))
sum=sum+i;
T(n)=1+1+(n+1)+n+(1+1)n
=3+4n=O(n)

5). int counter(){

int a=0;
cout<<”Enter a number”;
cin>>n;
for(i=0;i<n;i++)
a=a+1;
return 0; }
T(n)=1+1+1+(1+n+1+n)+2n+1
=4n+6=O(n)
22
6). void func( ){
int x=0; int i=0; int j=1;
cout<<”Enter a number”;
cin>>n;
while(i<n){
i=i+1;
}
while(j<n){
j=j+1;
}
}

T(n)=1+1+1+1+1+n+1+2n+n+2(n-1)
= 6+4n+2n-2
=4+6n=O(n)
23
7). int sum(int n){
int s=0;
for(int i=1;i<=n;i++)
s=s+(i*i*i*i);
return s;
}
T(n)=1+(1+n+1+n+5n)+1
=7n+4=O(n)

8). int sum=0;

for(i=0;i<n;i++)
for(j=0;j<n;j++)
sum++;
T(n)=1+1+(n+1)+n+n*(1+(n+1)+n+n)
=3+2n+n2+2n+2n2
=3+2n+3n2+2n
=3n2+4n+3=O(n2)
24
Next Class

• Formal Approach to
Analysis
• Asymptotic Analysis
• The Big-Oh Notation
• Big-Omega Notation
• Theta Notation
25