DEPARTMENT OF COMPUTER ENGINEERING

Semester

S.E. Semester IV Computer Engineering

Subject

Analysis of Algorithms

Lectures Professor In-charge

Prof. Sanjeev Dwivedi

Practicals Professor In-Charge

Prof. Ashwin Ganesan

Laboratory number

L07D

Student Name

Sakharam S. Gawade

Roll Number

14102C2015
Subject

Grade

Teachers

Signature

Experiment

01

Number
Experiment Title
Resources

To analyze bubble, selection and insertion sort

/

Computer, Code::Blocks(IDE)

Apparatus Used
Objectives
Set/

(Skill Algorithms of bubble, selection and insertion sort, C

Knowledge

tested/imparted)

Description of the experiment:

a) Bubble sort (sinking sort) is a simple sorting algorithm that repeatedly steps
through the list to be sorted, compares each pair of adjacent items and swaps
them if they are in the wrong order. The pass through the list is repeated until no
swaps are needed, which indicates that the list is sorted. The algorithm, which is a

comparison sort, is named for the way smaller elements "bubble" to the top of
the list.
for i = 1:n,
swapped = false
for j = n:i+1,
if a[j] < a[j-1],
swap a[j,j-1]
swapped = true
invariant: a[1..i] in final position
break if not swapped
end

Bubble sort has worst-case and average complexity both (n2), where n is the number
of items being sorted.
b) In selection sort we repeatedly find the next largest (or smallest) element in the

array and move it to its final position in the sorted array. We begin by selecting
the largest element and moving it to the highest index position. We then reduce
the effective size of the array by one element and repeat the process on the
smaller (sub) array. The process stops when the effective size of the array
becomes 1 (an array of 1 element is already sorted).
for i = 1:n,
k = i
for j = i+1:n, if a[j] < a[k], k = j
invariant: a[k] smallest of a[i..n]
swap a[i,k]
invariant: a[1..i] in final position
end

Selection sort has worst-case and average complexity both (n2), where n is the number
of items being sorted.

c) Every repetition of insertion sort removes an element from the input data,
inserting it into the correct position in the already-sorted list, until no input
elements remain. The choice of which element to remove from the input is
arbitrary, and can be made using almost any choice algorithm.
for i = 2:n,
for (k = i; k > 1 and a[k] < a[k-1]; k--)
swap a[k,k-1]
invariant: a[1..i] is sorted
end

Insertion sort has worst-case complexity (n2) and average complexity both (n), where
n is the number of items being sorted.

The program is supposed to analyze time complexity on the basis of multiple inputs
starting from low to high. To accept multiple inputs we require to create a file with
random numbers. Once one is created the program can now accept values. To calculate
the time we need to find the clock ticks between the start and end of the algorithm. The
clock ticks are then reduced to seconds and are then displayed for multiple algorithms
(which are bubble, selection and insertion sort) with respect to increasing number of
inputs.

Program:
/* Program
sort.*/

to

analyze

time

complexity

#include<stdio.h>
#include<time.h>
//Bubble Sort
int bubble(int arr[127610],long n)
{
clock_t t;
double time_taken;
long i,j;
int temp;
// Time Complexity for Bubble Sort
t=clock();
for(i=0;i<n;i++)
{
for(j=n-1;j>=i;j--)
{
if(arr[j]>arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];

of

bubble,

selection

and

insertion

arr[j+1]=temp;
}
}
}
t=clock()-t;
time_taken=((double)t)/CLOCKS_PER_SEC;
printf("%f\t\t",time_taken);
return 0;
}
//Selection Sort
int select(int arr[127610],long n)
{
clock_t t;
double time_taken;
FILE *f;
long i,j,p;
int min,temp;
// Time Complexity for Selection Sort
t=clock();
for(i=0;i<n;i++)
{
min=arr[i];
p=i;
for(j=i+1;j<n;j++)
{
if(arr[j]<min)
{
min=arr[j];

p=j;
}
}
temp=arr[i];
arr[i]=arr[p];
arr[p]=temp;
}
t=clock()-t;
time_taken=((double)t)/CLOCKS_PER_SEC;
printf("%f\t\t",time_taken);
return 0;
}
//Insertion Sort
int insert(int arr[127610],long n)
{
clock_t t;
double time_taken;
int temp,x;
long i,j;
// Time Complexity for Insertion Sort
t=clock();
for(i=1;i<n;i++)
{
j=i;
x=arr[i];
while(arr[j-1]>x&&j>0)
{
arr[j]=arr[j-1];

j--;
}
arr[j]=x;
}
t=clock()-t;
time_taken=((double)t)/CLOCKS_PER_SEC;
printf("%f\t\t",time_taken);
return 0;
}
int main()
{
FILE *f;

long i,n=10;
int num[127610];
printf("No
Sort\n\n");

of

I/P\tBubble

Sort\t\tSelection

Sort\t\tInsertion

f=fopen("GenRan.txt","r"); //Reads random values from a text file

while(n<=100000)
{
printf("%d\t\t",n);

for(i=0;i<n;i++)
fscanf(f,"%d",&num[i]);
bubble(num,n);

for(i=0;i<n;i++)
fscanf(f,"%d",&num[i]);
select(num,n);

for(i=0;i<n;i++)
fscanf(f,"%d",&num[i]);
insert(num,n);

n=n*10;
}
return 0;
}

Output run:

Conclusions:
We analyzed three simple sorting algorithms bubble, selection and insertion sort and we
can conclude that bubble sort is simple but it takes longer time as compared to others.
Selection sort theoretically should take similar time as bubble sort but practically it is
better than bubble sort whereas insertion sort works best among all the three
algorithms.