ADA_2_Analysis of Algorithms

Prepared by:
Prof. Khushali B Kathiriya
SUB. CODE: 3150703
SEMESTER :5TH IT

▪ The efficient algorithm
▪ Average, Best and worst case analysis
▪ Amortized analysis
▪ Asymptotic Notations
▪ Analyzing control statement
▪ Loop invariant and the correctness of the algorithm
▪ Sorting Algorithms and analysis:
▪ Bubble sort, Selection sort, Insertion sort, Shell sort Heap sort
▪ Sorting in linear time :
▪ Bucket sort, Radix sort and Counting sort
Prepared by: Prof. Khushali B Kathiriya 2

Prepared by:
Prof. Khushali B Kathiriya

Efficiency of Algorithm
Time Complexity
Space
Complexity

▪ Importance of Efficiency analysis
1. By computing the time complexity we come to know whether algorithm is slow or
fast.
2. By computing the space complexity we come to know whether algorithm requires
more or less space.

▪ Example-1
▪ The FC is a count that denotes how many times particular statement is executed.
Void fun()
{
int a;
a=10;
printf(“%d”, a);
}
Void fun()
{
int a;
a=10; ……………………………………… 1 time
printf(“%d”, a); …………………….... 1 time
}

▪ Example-2
void Display()
{
int a, b, c;
a = 10;
b = 20;
c = a + b;
printf (“%d”,c);
}
CODE Frequency Count
a = 10 1
b = 20 1
c = a + b 1
printf (“%d”, c ) 1
Total 4

▪ Example-3
Void fun()
{
int a;
a=0;
for(i=0; i<=n; i++)
{
a = a +i;
}
printf(“%d”, a);
}
Void fun()
{
int a;
a=0; …………………………………………………. 1 time
for(i=0; i<=n; i++) ………………………………….. N +1 time
{
a = a +i; ………………………………………….. N time
}
printf(“%d”, a); ………………………………………1 time
}

▪ Example-4
for(i=0; i<=n; i++)
{
for(j=1; j<=n; j++)
{
c[i][j]=0;
for(k=1;k<=n; k++)
{
c[i][j]= c[i][j]+a[i][k] * b[k][j];
}
}
}
for(i=0; i<=n; i++)
{
for(j=1; j<=n; j++)
{
c[i][j]=0;
for(k=1;k<=n; k++)
{
c[i][j]= c[i][j]+a[i][k] * b[k][j];
}
}
}
………………………….n+1
………………………….n(n+1)
………………………….n*n
………………………….n*n*(n+1)
…….n*n*n

▪ Example-4 (Cont.)
▪ Total time
=(n+1) + n(n+1) + n*n + n*n*(n+1) + (n*n*n)
= 2𝑛3 + 3𝑛2 + 2n +1
for(i=0; i<=n; i++)
{
for(j=1; j<=n; j++)
{
c[i][j]=0;
for(k=1;k<=n; k++)
{
c[i][j]= c[i][j]+a[i][k] * b[k][j];
}
}
}
………………………….n+1
………………………….n(n+1)
………………………….n*n
………………………….n*n*(n+1)
…….n*n*n

▪ We can have three cases to analyze an algorithm:
1. The Worst Case
2. Average Case
3. Best Case

▪ If Algorithm takes minimum time to solve the problem for given set of input, it is
called best case time complexity.
▪ In the best case analysis, we calculate lower bound on running time of an algorithm.
We must know the case that causes minimum number of operations to be executed.
▪ We can denote the best case time complexity as
▪ 𝑪𝒃𝒆𝒔𝒕 = 1 Or T(n) = Θ(1)

▪ If Algorithm takes maximum time to solve the problem for given set of input, it is
called worst case time complexity.
▪ In the worst case analysis, we calculate upper bound on running time of an
algorithm. We must know the case that causes maximum number of operations to be
executed.
▪ Therefore, the worst case time complexity of linear search would be T(n)= Θ(n).

▪ Input sequence which is neighed best nor worst is called average case.
▪ It gives general behaviour of an algorithm.
▪ CAVG(n) = Probability of successful search + Probability of unsuccessful search
▪ CAVG(n) = 1.
P
n
+ 2.
P
n
+ … +. i
P
n
+ n. 1 − P
=
P
n
[1 + 2 + .. i … n ] + n(1-P)
=
P
n
.
n (n+1)
2
+ n (1-P)
=
P (n+1)
2
+ n (1-P)

▪ CAVG(n) =
P (n+1)
2
+ n (1-P)
▪ Suppose if P=0,
▪ CAVG(n) =
P (n+1)
2
+ n (1-P)
=
0 (n+1)
2
+ n (1-0)
= n
▪ Suppose if P=1,
▪ CAVG(n) =
P (n+1)
2
+ n (1-P)
=
1 (n+1)
2
+ n (1-1)
=
(n+1)
2

▪ To choose the best algo., we need to check efficiency of each algorithm. The
efficiency can be measured by computing time complexity of each algorithm.
▪ Using Asymptotic Notations we can give time complexity as “fastest”, “slowest”, or
“ average” possible time.
Asymptotic
Notations
Big oh Notation
(O)
Omega Notation
(Ω)
Theta Notation
(Θ)

O
▪ It represents the upper bound of the runtime of an algorithm.
▪ Big O Notation's role is to calculate the longest time an algorithm can take for its
execution,
▪ i.e., it is used for calculating the worst-case time complexity of an algorithm.
▪ Let f(n) and g(n) be 2 non-negative functions.
▪ We want: f(n) = O(g(n))
▪ So we can write i.e., f(n) ≤ c * g(n)
▪ Where, c>0, n>=k, k>=0.
▪ Then f(n) is big oh of g(n) or f(n) ∈ O(g(n)).

O
▪ f(n) ≤ c * g(n)

O
▪ Example-1: Consider function f(n)= 2n+2 and g(n)= 𝑛2
. Then we have to find some
constant c.
▪ So, we can conclude that for n>2, we obtain f(n)<g(n).
n=1,
f(n)=2n+2
f(1)=2(1)+2 = 4
g(n) = 𝑛2
g(1) = 12 = 1
So, f(n) > g(n).
n=2,
f(n)=2n+2
f(2)=2(2)+2 = 6
g(n) = 𝑛2
g(2) = 22 = 4
So, f(n) > g(n).
n=3,
f(n)=2n+2
f(3)=2(3)+2 = 8
g(n) = 𝑛2
g(3) = 32 = 9
So, f(n) < g(n).

O
23
Prepared by: Prof. Khushali B Kathiriya

Ω
▪ It represents the lower bound of the runtime of an algorithm.
▪ Big Ω Notation's role is to calculate the shortest amount of time an algorithm can
take for its execution,
▪ i.e., it is used for calculating the best time complexity of an algorithm.
▪ Let f(n) and g(n) be 2 non-negative functions.
▪ We want: f(n) = O(g(n))
▪ So we can write i.e., f(n) ≥ c * g(n)
▪ Where, c>0, n>=k, k>=0.
▪ Then f(n) is big oh of g(n) or f(n) ∈ O(g(n)).

Ω
▪ f(n) ≥ c * g(n)

Ω
▪ Example-1: Consider function f(n)= 2𝑛2
+5 and g(n)=7n. Then we have to find some
constant c.
▪ So, we can conclude that for n>1, we obtain f(n) ≥ g(n).
n=1,
f(n)= 2𝑛2
+5
f(1)= 2(1)2
+5 = 7
g(n) =7n
g(1) = 7(1)= 7
So, f(n) ≥ g(n).
n=2,
f(n)= 2𝑛2
+5
f(2)=2(2)2
+5 = 13
g(n) =7n
g(2) = 7(2)= 14
So, f(n) ≥ g(n).

Ω

▪ By this method the running time is between upper and lower bound.
▪ C1* g(n) ≤ f(n) ≤ C2 * g(n)
▪ Then we can say that,
▪ F(n) ∈ 𝜃 (g(n))

(Most IMP)

▪ Arranging the elements in increasing order or decreasing order.
▪ It can be
▪ Number(0-9),
▪ Character ( A- Z)
▪ String
▪ Records etc.

1. Bubble sort
2. Selection sort
3. Insertion sort
4. Shell sort
5. Heap sort
6. Bucket sort
7. Radix sort
8. Counting sort
Sorting in Linear time

59

▪ Consider elements for bubble sort
1. 70, 30, 20, 50, 60, 10, 40
2. DESIGN

67

▪ Consider elements for selection sort
1. 70, 30, 20, 50, 60, 10, 40
2. ANALYSIS

75

76

▪ Consider elements for insertion sort
1. 70, 30, 20, 50, 60, 10, 40

▪ This method is a improvement over the simple insertion sort.
▪ In this method the elements at fixed distance are compared. The distance will then
decremented by the fixed amount and again the comparison will be made.

61 109 149 111 34 2 24 119 122 125 27 145
12 Elements

▪ Total elements N =12
▪ So here,
K= N/2
K=12/2
K=6(K is distance between arrry set)

61 109 149 111 34 2 24 119 122 125 27 145
▪ K= 6

61 109 149 111 34 2 24 119 122 125 27 145
▪ K= 6
24 109 149 111 34 2 61 119 122 125 27 145

▪ K=6
24 109 149 111 34 2 62 119 122 125 27 145
24 109 149 111 34 2 61 119 122 125 27 145

▪ K=6
24 109 149 111 34 2 62 119 122 125 27 145
24 109 122 111 34 2 61 119 149 125 27 145

▪ K=6
24 109 149 111 34 2 62 119 122 125 27 145
24 109 122 111 27 2 61 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 109 122 111 27 2 61 119 149 125 34 145
24 109 122 111 27 2 61 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 109 122 111 27 2 61 119 149 125 34 145
24 27 122 111 109 2 61 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 109 122 111 27 2 61 119 149 125 34 145
24 27 2 111 109 122 61 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 109 2 111 109 122 61 119 149 125 34 145
24 27 2 61 109 122 111 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 27 2 61 109 122 111 119 149 125 34 145
24 27 2 61 109 122 111 119 149 125 34 145

▪ K=K/2 = 6/2 = 3
24 27 2 61 109 122 111 119 149 125 34 145
24 27 2 61 109 122 111 34 149 125 119 145

▪ K=K/2 = 6/2 = 3
24 27 2 61 109 122 111 34 149 125 119 145
24 27 2 61 109 122 111 34 145 125 119 149

▪ K=K/2 = 6/2 = 3
24 27 2 61 109 122 111 34 145 125 119 149
24 27 2 61 34 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
24 27 2 61 34 122 111 109 145 125 119 149
24 27 2 61 34 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
24 2 27 61 34 122 111 109 145 125 119 149
24 2 27 61 34 122 111 109 145 125 119 149
2 24 27 61 34 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 61 34 122 111 109 145 125 119 149
2 24 27 61 34 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 61 34 122 111 109 145 125 119 149
2 24 27 34 61 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 122 111 109 145 125 119 149
2 24 27 34 61 122 111 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 122 111 109 145 125 119 149
2 24 27 34 61 111 122 109 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 111 122 109 145 125 119 149
2 24 27 34 61 111 109 122 145 125 119 149
2 24 27 34 61 109 111 122 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 109 111 122 145 125 119 149
2 24 27 34 61 109 111 122 145 125 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 109 111 122 145 125 119 149
2 24 27 34 61 109 111 122 125 145 119 149

▪ K=K/2 =3 /2 = 1.5 = 1
2 24 27 34 61 109 111 122 125 145 119 149
2 24 27 34 61 109 111 122 125 119 145 149
2 24 27 34 61 109 111 122 119 125 145 149
2 24 27 34 61 109 111 119 122 125 145 149

▪ Consider elements for shell sort
1. 70, 30, 20, 50, 60, 10, 40

Heap Sort
Heap
Construction
Deletion of
maximum
key

▪ Array = [14, 12 , 9, 8, 7, 10 , 18]
▪ Step:1
▪ Heap Construction
14
9
12
7
8 10 18

▪ Step: 2
▪ Start Heaping from bottom and Swap with maximum no.
14
18
12
7
8 10 9
14
9
12
7
8 10 18
Array = [14, 12 , 18, 8, 7, 10 , 9]
Swap with maximum
no.

▪ Step:3
▪ Heaping from top and swapping with maximum no.
14
18
12
7
8 10 9
18
14
12
7
8 10 9
Array = [18, 12 , 14, 8, 7, 10 , 9]

▪ Step: 4
▪ Swapping with last node and then delete maximum number
18
14
12
7
8 10 9
9
14
12
7
8 10 18
Array = [9, 12 , 14, 8, 7, 10 , 18]

▪ Step: 5
▪ Heaping with maximum number
9
14
12
7
8 10
14
9
12
7
8 10
Array = [14, 12 , 9, 8, 7, 10 | 18]

▪ Step: 6
14
9
12
7
8 10
10
9
12
7
8 14
Array = [10, 12 , 9, 8, 7| 14 , 18]

▪ Step: 7
10
9
12
7
8
12
9
10
7
8
Array = [12, 10 , 9, 8, 7 | 14, 18]

▪ Step: 8
7
9
10
12
8
7
9
10
8
Array = [7, 10 , 9, 8 |12, 14, 18]

▪ Step : 9
7
9
10
8
10
9
7
8
10
9
8
7
Array = [10 , 8, 9, 7 |12, 14, 18]

▪ Step: 10
7
9
8
10
7
9
8
Array = [ 7, 8, 9 |10, 12, 14, 18]

▪ Step: 11
7
9
8
9
7
8
7
9
8
7
8
Array = [ 7, 8 |9, 10, 12, 14, 18]

▪ Step: 12
7
8
7
Array = [ 7 |8, 9, 10, 12, 14, 18]
Array = [ 7, 8, 9, 10, 12, 14, 18] : Sorted Array

▪ Consider elements for heap sort
1. 70, 30, 20, 50, 60, 10, 40

▪ In this sort method array is partitioned into buckets.
▪ Each bucket is then sorted individually, using some other sorting algorithm such as
insertion sort.
▪ Algorithm
1. Set up array of initially empty buckets
2. Put each element in corresponding bucket
3. Sort each non empty bucket
4. Visit the buckets in order and put all the elements into a sequence and print them.

▪ Array= [0.56, 0.12, 0.84, 0.56, 0.28, 0, -0.13, 0.47, 0.94, 0.31, 0.12, -0.2]
▪ Here we have 12 elements.
▪ Now we generate our buckets from 0 to 9.

0
1
2
3
4
5
6
7
8
9
▪ Step: 1
▪ Generate bucket from 0 to 1

▪ Step: 2
▪ Fill bucket using given array
▪ Array= [0.56, 0.12, 0.84, 0.56, 0.28, 0, -0.13, 0.47, 0.94, 0.31, 0.12, -0.2]
0
1
2
3
4
5
6
7
8
9
0.56
0.12
0.84
0.56
0.28
0 -0.13
0.47
0.94
0.31
0.12
-0.2

▪ Step: 3
▪ Sort each non empty bucket
130
0
1
2
3
4
5
6
7
8
9
0.56
0.12
0.84
0.56
0.28
0 -0.13
0.47
0.94
0.31
0.12
-0.2 0
1
2
3
4
5
6
7
8
9
-0.2,-0.13,0
0.12, 0.12
0.28
0.47
0.31
0.56 , 0.56
0.84
0.94

▪ Step: 4
▪ Put all elements bucket vise in one sequence
131
0
1
2
3
4
5
6
7
8
9
-0.2,-0.13,0
0.12, 0.12
0.28
0.47
0.31
0.56 , 0.56
0.84
0.94
Sorted array is:
[-0.2,-0.13,0,0.12,0.12,0.28, 0.31, 0.47, 0.56, 0.56, 0.84, 0.94 ]

▪ Consider elements for Bucket sort
1. 121,235,456,123,674,01,90,10,56,45,87,899

140

ADA_2_Analysis of Algorithms

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

More from Khushali Kathiriya

More from Khushali Kathiriya (20)

Recently uploaded

Recently uploaded (20)

ADA_2_Analysis of Algorithms