Sorting_project_2.pdf

Koneru Lakshmaiah Education Foundation
(Deemed to be University)
FRESHMAN ENGINEERING DEPARTMENT
A Project Based Lab Report
On
Comparative study on sorting algorithms
SUBMITTED BY:
I.D NUMBER NAME
180040628 KODE VENKATA KRISHNA
UNDER THE GUIDANCE OF
Mr.BEKKANTI ASHOK SIR
KL UNIVERSITY
Green fields, Vaddeswaram – 522 502
Guntur Dt., AP, India.

DEPARTMENT OF BASIC ENGINEERING SCIENCES-1
CERTIFICATE
This is to certify that the project based laboratory report entitled
Comparative study on sorting algorithms submitted by G.KEERTHI
PRASANNA bearing Regd. No. 180040625 to the Department of Electronics
and Communication Engineering-1, KL University in partial fulfillment of the
requirements for the completion of a project based Laboratory in “TECHNICAL
SKILLS-1(CODING)”course in I B Tech II Semester, is a bonafide record of the
work carried out by him/her under my supervision during the academic year
2018 –
2019.
PROJECT SUPERVISOR HEAD OF THE DEPARTMENT
BEKKANTI ASHOK SIR

ACKNOWLEDGEMENTS
It is great pleasure for me to express my gratitude to our honorable
President Sri. Koneru Satyanarayana, for giving the opportunity and platform
with facilities in accomplishing the project based laboratory report.
I express the sincere gratitude to our principal Prof Dr. N.Venkataram for
his administration towards our academic growth.
I express sincere gratitude to HOD-BES-1 for his leadership and constant
motivation provided in successful completion of our academic semester. I record
it as my privilege to deeply thank for providing us the efficient faculty and
facilities to make our ideas into reality.
I express my sincere thank to our project supervisor Mr.BEKKANTI ASHOK
for his novel association of ideas, encouragement, appreciation and intellectual
zeal which motivated us to venture this project successfully.
Finally, it is pleased to acknowledge the indebtedness to all those who
devoted themselves directly or indirectly to make this project report success.
Name: Id.No
K.VENKATA KRISHNA 180040631

ABSTRACT
To make the student easier to study how the operations on Data Structure
Various Algorithms are performed.The Data Structues can bstack,queue and
linked list etc and algorithms are sorting like bubble sort,insertion sort etc.Aim
behind implementation of this project to make a clear understandability of
various algorithms of data structures. Using a web page this will simulates the
data structure operations such as searching, sorting, insertion, deletion etc. In
array, stack, queue, and linked list as well. Thus,our web page provides
effective and efficient knowledge of data structures. This also provide some
theoretical knowledge regarding the data structure

INDEX
S.NO TITLE PAGE NO
1. Introduction 6
.
2. Aim of the project 7
2.1 Advantages & Disadvantages 8
2.2 Future Implementation 9
3 Software & Hardware Details 10
4 Data Flow Diagram 11
5 Implementation 12
6 Algorithm 13
7 Integration and System Testing 19
8 Conclusion 21

INTRODUCTION
Sorting is nothing but arranging the data in ascending or descending
order. The term sorting came into picture, as humans realised the
importance of searching quickly.sorting is easier to identify the elements
in the complex part of appilications.There are so many things in our real
life that we need to search for, like a particular record in database, roll
numbers in merit list, a particular telephone number in telephone
directory, a particular page in a book etc. All this would have been a
mess if the data was kept unordered and
unsorted, but fortunately the concept of sorting came into existence,
making it easier for everyone to arrange data in an order, hence making
it easier to search. In computer science, a sorting algorithm is
an algorithm that puts elements of a list in a certain order. The most
frequently used orders are numerical order and lexicographical order.
Efficient sorting is important for optimizing the efficiency of other
algorithms (such as search and merge algorithms) which require input
data to be in sorted lists. Sorting is also often useful
for cannibalising data and for producing human-readable output. More
formally, the output of any sorting algorithm must satisfy two conditions:
1. The output is in nondecreasing order (each element is no smaller
than the previous element according to the desired total order);
2. The output is a permutation (a reordering, yet retaining all of the
original elements) of the input.
Further, the input data is often stored in an array, which allows random
access, rather than a stack, which only allows sequential access; though
many algorithms can be applied to either type of data after suitable
modifying.

AIM
The main aim of this project is to Implement a variety of
comparison sort algorithms as generic algorithms, including
Insertion Sort, Selection Sort, Heap Sort, Merge Sort, and Quick
Sort, re-using code as much as possible from the course library.
The implementations should cover both default order and
order by passed predicate object.Discuss the capabilities and
use constraints for each of these generic algorithms, including
assumptions on assumed iterator type, worst and average case
runtimes.
• Implement the Counting Sort algorithm for specified arrays of
integers
• Implement the Counting Sort algorithm as a template function
taking function object parameter that is used to define the sort
value of the input integers, obtaining Bit Sort and Reverse Sort
as special cases.
• Collect data and use the method of least squares to find a best
fit scalability curve for each sort algorithm (including Counting
Sort), based on a form derived from the known asymptotic
runtime for the algorithm.
• Perform a comparative qualitative analysis of these algorithms
using asymptotic runtime analysis as well as quantitative
analysis using data collected from implementations.

Advantages:-To find the time complexity and space complexity of
various sorting techniques.
Disadvantages:-Many sorting techniques are having more time
complexity so one efficient program is enough.
Future enhancements:-More efficient programs with less time
complexity and space complexity can be discovered implemented.

SYSTEM REQUIREMENTS
SOFTWARE REQUIREMENTS:
The major software requirements of the project are as follows:
Language : Turbo-C
Operating system:Windows Xp or later.
HARDWAREREQUIREMEsNTS:
The hardware requirements that map towards the software are as
Follows:
RAM : 512 MB
Processor :Dev –c++,64-bit compiler.

ALGORITHM
Insertion sort
1. FOR j ← 2 TO length[A]
2. DO key ← A[j]
3. {Put A[j] into the sorted sequence A[1 . . j − 1]}
4. i ← j − 1
5. WHILE i > 0 and A[i] > key
6. DO A[i +1] ← A[i]
7. i ← i − 1 8. A[i + 1] ← key
Selection sort
Step 1 : Repeat For K = 0 to N – 2 Begin
Step 2 : Set POS = K
Step 3 : Repeat for J = K + 1 to N – 1 Begin If A[ J ] < A [ POS ] Set POS = J End
For
Step 5 : Swap A [ K ] with A [ POS ] End For
Step 6 : Exit
Quick sort
quicksort(q)
varlist less, pivotList, greater
if length(q) ≤ 1
return q
select a pivot value pivot from q
for each x in q except the pivot element

if x < pivot then add x to less
if x ≥ pivot then add x to greater
add pivot to pivotList
return concatenate(quicksort(less),
pivotList, quicksort(greater))
Merge sort
MergeSort(arr[], l, r)
If r > l
1. Find the middle point to divide the array into two halves:
middle m = (l+r)/2
2. Call mergeSort for first half:
Call mergeSort(arr, l, m)
3. Call mergeSort for second half:
Call mergeSort(arr, m+1, r)
4. Merge the two halves sorted in step 2 and 3:
Call merge(arr, l, m, r)
Heap sort
HEAPSORT( array A, int n)
{
BUILD-HEAP(A, n)
m ← n while (m ≥ 2)
do
SWAP (A[1], A[m])
m ← m− 1 HEAPIFY (A, 1, m)

}
The heapify procedure is given by HEAPIFY( array A, int i, int m)
{
l ← LEFT(i)
r ← RIGHT(i)
max ← i
if (l ≤ m) and (A[l] > A[max])
then max ← l if (r ≤ m) and (A[r] > A[max])
then max ← r if (max ≠ i)
then SWAP (A[i], A[max])
HEAPIFY (A, max, m)
}

IMPLEMENTATION
#include<stdio.h>
#include<stdlib.h>
void insertion(int a[],int n)
{
int i,j,tmp;
for(i=1;i<n;i++)
{
tmp=a[i];
for(j=i;j>0&&tmp<a[j-1];j--)
a[j]=a[j-1];
a[j]=tmp;
}
}
void shell(int a[1000],int n)
{
int i,j,gap,tmp,c;
for(gap=n/2;gap>=1;gap=gap/2)
{
for(i=gap;i<=n-1;i++)

{
tmp=a[i];
for(j=i-gap;j>=0&&tmp<a[j];j=j-gap)
{
a[j+gap]=a[j];
}
a[j+gap]=tmp;
}}}
void selection(int a[1000],int n)
{
int i,j,mid,tmp;
for(i=0;i<n;i++)
{
mid=i;
for(j=i+1;j<=n-1;j++)
{
if(a[j]<a[mid])
mid=j;
}
tmp=a[i];

a[i]=a[mid];
a[mid]=tmp;
}
}
void quick(int a[],int low,int high)
{
int pivot=a[low],i,j,tmp;
if(low<high)
{
pivot=a[low];
i=low+1;
j=high;
while(i<=j)
{
while(a[i]<pivot)
i++;
while(a[j]>pivot)
j--;
if(i<j)
{

tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}}
a[low]=a[j];
a[j]=pivot;
quick(a,low,j-1);
quick(a,j+1,high);
}
}
void merge(int a[],int low,int mid,int high)
{
int i,j,k,tmp[100]={0};
i=low;
j=mid+1;
k=low;
while(i<=mid&&j<=high)
{
if(a[i]<a[j])
{

tmp[k++]=a[i++];
}
else
{
tmp[k++]=a[j++];
}
}
while(j<=high)
{
tmp[k++]=a[j++];
}
while(i<=mid)
{
tmp[k++]=a[i++];
}
for(i=low;i<=high;i++)
a[i]=tmp[i];
}
void partition(int a[],int low,int high)
{

int mid;
if(low<high)
{
mid=(low+high)/2;
partition(a,low,mid);
partition(a,mid+1,high);
merge(a,low,mid,high);
}
}
void percdown(int a[],int n,int i);
void heapsort(int a[],int n)
{
int i,tmp,child;
for(i=n/2;i>=0;i--)
percdown(a,i,n);
for(i=n-1;i>0;i--)
{
tmp=a[0];
a[0]=a[i];
a[i]=tmp;

percdown(a,0,i);
}
}
void percdown(int a[],int i,int n)
{
int child,tmp;
for(tmp=a[i];2*i+1<n;i=child)
{
child=2*i+1;
if(child!=n-1&&a[child+1]>a[child])
child++;
if(tmp<a[child])
{
tmp=a[i];
a[i]=a[child];
a[child]=tmp;
else
break;
}
a[i]=tmp;

}
int main()
{
int n,a[1000],i,c,j,low=0,high=n-1;
while(1)
{
printf("enter array size");
scanf("%d",&n);
printf("enter array");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
int req;
printf("nenter 1 for insertion sortn enter 2 for shell
sortn enter 3 for selection sortn enter 4 for quick sortn
enter 5 for merge sortn enter 6 for heap sortn PRESS
ANY KEY OTHER THAN 1,2,3,4,5,6 TO EXITn");
scanf("%dn",&req);
switch(req)
{
case 1:insertion(a,n);
for(i=0;i<n;i++)

printf("%dt",a[i]);
break;
case 2:shell(a,n);
for(i=0;i<n;i++)
printf("%dt",a[i]);
break;
case 3:selection(a,n);
for(i=0;i<n;i++)
printf("%dt",a[i]);
break;
case 4:quick(a, low,high);
low=0;
high=n-1;
for(i=0;i<n;i++)
printf("%dt",a[i]);
break;
case 5:
partition(a,low,high);
for(i=0;i<n;i++)
printf("%dt",a[i]);

break;
case 6: heapsort(a,n);
printf("sorted datan");
for(j=0;j<n;j++)
printf("%dt",a[j]);
break;
default:exit(0);
}}return 0;
}

INTEGRATION AND SYSTEM TESTING
OUTPUTS
Screen Shots:

Conclusion:
Best average worst
Insertion O(n) O(n^2) O(n^2)
Shell sort O(n^2) O(n^2) O(n^2)
Quick sort O(nlogn) O(nlogn) O(n^2)
Merge sort O(nlogn) O(nlogn) O(nlogn)
Selection sort O(n^2) O(n^2) O(n^2)
So of all the sorting techniques
Merge Sort is the fastest stable sorting algorithm with worst-case
complexity of O(nlogn), but it requires extra space. Although, if memory
constraints are very tight you can use Quick Sort, whose worst-time
compelxity is O( ) but average case complexity is O(nlogn).

Sorting_project_2.pdf

Recommended

Recommended

More Related Content

Similar to Sorting_project_2.pdf

Similar to Sorting_project_2.pdf (20)

Recently uploaded

Recently uploaded (20)

Sorting_project_2.pdf