Scribd
Upload
104 views

On Implementation of Merge Sort: Kushal Jangid April 6, 2015

This document reports on the implementation of merge sort. It includes explanations of the merge sort algorithm and its divide and conquer approach. Pseudocode and analysis show that merge sort has a time complexity of O(n log n). Code implementing merge sort in C is provided, along with sample output testing the sorting of input arrays. The conclusion states that merge sort performs well for large inputs due to its favorable time complexity compared to other sorting algorithms.

Uploaded by

Gaurav Tolani
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
104 views

On Implementation of Merge Sort: Kushal Jangid April 6, 2015

This document reports on the implementation of merge sort. It includes explanations of the merge sort algorithm and its divide and conquer approach. Pseudocode and analysis show that merge sort has a time complexity of O(n log n). Code implementing merge sort in C is provided, along with sample output testing the sorting of input arrays. The conclusion states that merge sort performs well for large inputs due to its favorable time complexity compared to other sorting algorithms.

Uploaded by

Gaurav Tolani
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

Report

on
Implementation of Merge Sort
Kushal Jangid
April 6, 2015

Contents
Assumptions . . . . . . . . . . . .
Explanations . . . . . . . . . . . .
Algorithms . . . . . . . . . . . . .
Analysis of complexity and running
Code . . . . . . . . . . . . . . . . .
Output and Testing Results . . . .
Conclusions . . . . . . . . . . . . .

. . .
. . .
. . .
time
. . .
. . .
. . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

. 3
. 3
. 4
. 6
. 7
. 9
. 10

Assumptions :
I am writing a lab report for merge sort and there are several assumptions
that i take to write this program. I am taking a finite length array means the
maximum length of the array should be there in the program. It also checks
for overflow and underflow errors.To implement this algorithm we are going
to use divide and coquer approach.

Explanations :
Merge sort is based on the divide-and-conquer paradigm. Its worst-case running time has a lower order of growth than insertion sort. Since we are
dealing with subproblems, we state each subproblem as sorting a subarray
A[p .. r]. Initially, p = 1 and r = n, but these values change as we recurse
through subproblems.
To sort A[p .. r]:
1. Divide Step :
If a given array A has zero or one element, simply return; it is already sorted. Otherwise, split A[p .. r] into two subarrays A[p .. q]
and A[q + 1 .. r], each containing about half of the elements of A[p ..
r]. That is, q is the halfway point of A[p .. r].
2. Conquer Step :
Conquer by recursively sorting the two subarrays A[p .. q] and A[q
+ 1 .. r].
3. Combine Step :
Combine the elements back in A[p .. r] by merging the two sorted
subarrays A[p .. q] and A[q + 1 .. r] into a sorted sequence. To
accomplish this step, we will define a procedure MERGE (A, p, q, r).
Note that the recursion bottoms out when the subarray has just one
element, so that it is trivially sorted.
3

Algorithms:
To sort the entire sequence A[1 .. n], make the initial call to the procedure
MERGE-SORT (A, 1, n).

Merging :
What remains is the MERGE procedure. The following is the input and
output of the MERGE procedure.
Input: Array A and indices p, q, r such that p q r and subarray A[p ..
q] is sorted and subarray A[q + 1 .. r] is sorted. By restrictions on p, q, r,
neither subarray is empty.
Output: The two subarrays are merged into a single sorted subarray in
A[p .. r].
We implement it so that it takes (n) time, where n = r p + 1, which is
the number of elements being merged.
The pseudocode of the MERGE procedure is as follow:

Example: A call of MERGE(A, 9, 12, 16). Read the following figure row
by row. That is how we have done in the class.
The first part shows the arrays at the start of the for k p to r loop,
where A[p . . q] is copied into L[1 . . n1] and A[q + 1 . . r ] is copied into
R[1 . . n2].
Succeeding parts show the situation at the start of successive iterations.
Entries in A with slashes have had their values copied to either L or R
and have not had a value copied back in yet. Entries in L and R with slashes
have been copied back into A.
The last part shows that the subarrays are merged back into A[p . . r],
which is now sorted, and that only the sentinels () are exposed in the arrays
L and R.]

Analysis of complexity and running time:


Lets analysis the complexity of this algorithm.
The first two for loops (that is, the loop in line 4 and the loop in line 6)
take (n1 + n2) = (n) time. The last for loop (that is, the loop in line 12)
makes n iterations, each taking constant time, for (n) time. Therefore, the
total running time is (n).
Analyzing Merge Sort :

For simplicity, assume that n is a power of 2 so that each divide step yields
two subproblems, both of size exactly n/2.
The base case occurs when n = 1.
When n 2, time for merge sort steps:
Divide: Just compute q as the average of p and r, which takes constant
time i.e. (1).
Conquer: Recursively solve 2 subproblems, each of size n/2, which is
2T(n/2).
Combine: MERGE on an n-element subarray takes (n) time.
Summed together they give a function that is linear in n, which is (n).
Therefore, the recurrence for merge sort running time is

The solution for this kind of the recurrence relation is given by the master
theorem. So the complexity of merge sort is (nlogn).

Code:
Here is the code for merge sort.

include<stdio.h>
#include<conio.h>
void merge(int [],int ,int ,int );
void part(int [],int ,int );
int main()
{
int arr[30];
int i,size;

printf("\n\t------- Merge sorting method -------\n\n");


printf("Enter total no. of elements : ");
scanf("%d",&size);
for(i=0; i<size; i++)
{
printf("Enter %d element : ",i+1);
scanf("%d",&arr[i]);
}
part(arr,0,size-1);
printf("\n\t------- Merge sorted elements -------\n\n");
for(i=0; i<size; i++)
printf("%d ",arr[i]);
getch();
return 0;
}

void part(int arr[],int min,int max)


{
int mid;
if(min<max)
{
mid=(min+max)/2;
part(arr,min,mid);
part(arr,mid+1,max);
merge(arr,min,mid,max);
}
}

void merge(int arr[],int min,int mid,int max)


{
int tmp[30];
int i,j,k,m;
j=min;
m=mid+1;
for(i=min; j<=mid && m<=max ; i++)
{
if(arr[j]<=arr[m])
{

tmp[i]=arr[j];
j++;
}
else
{
tmp[i]=arr[m];
m++;
}
}
if(j>mid)
{
for(k=m; k<=max; k++)
{
tmp[i]=arr[k];
i++;
}
}
else
{
for(k=j; k<=mid; k++)
{
tmp[i]=arr[k];
i++;
}
}
for(k=min; k<=max; k++)
arr[k]=tmp[k];
}

Output and Testing Results:


The output for the merge sort is given.

Conclusions :
The final conclusion is that merge sort is good when there is large number
of inputs as its complexity is good in compare to other sorting algorithms.
The future work in this domain can be to explore the good technique so that
we can reduce the running time for this sort

10

You might also like