This slide is about the simulation and code of "Merge Sort" to understand what "Merge Sort" is .

1. Merge sort
Created by : Rakib & Tahmeed
1

2. Created & Edited By:
Md.
Rakib
Trofder
•BSSE1129
Tahmeed
Mahbub
•BSSE1127
2

3. What is Merge Sort
Merge Sort is one kind of sorting
that based on Divide and
Conquer algorithm .
3

4. How it works
•
It divides input array in two
halves , calls itself (using
recursive function) for the
two halves and then merges
the two sorted halves .
4

5. Merge sort Simulation
Unsorted element 
56 32 16 23 9 17 3 21
5

6. Dividing the array
56 32 16 23 9 17 3 21
56 32 16 23 9 17 3 21
56 32 16 23 9 17 3 21
56 32 16 23 9 17 3 21
6

7. Merging the array
56 32 16 23 9 17 3 21
5632 16 23 9 17 3 21
563216 23 9 173 21
563216 239 173 21
7

8. Sorted element 
563216 239 173 21
8

9. Analysis of Sorting
Main
function
Merge_sort
function
Merging
Function
9

10. Code of Main Function
#include<stdio.h>
#include<stdlib.h>
void merge_sort(int , int);
void merging(int ,int ,int);
int a[] ={56,32,16,23,9,17,3,21};
int main()
{
int i,n=8;
merge_sort(0,n);
for(i=0;i<=n; i++)
{
printf("%d ",a[i]);
}
return 0;
}
10

11. Code of Merge_Sort
void merge_sort(int left , int right)
{
if(left>=right)
{
return ;
}
int mid= left + (right-left)/2;
merge_sort( left, mid);
merge_sort( mid+1, right) ;
merging( left, mid, right );
}
11

12. Code of Merging Function (part-1)
void merging(int left,int mid,int right)
{
int i;
int k, left_index =0, right_index =0;
int L_size, R_size;
int p,q;
L_size = mid-left+1;
R_size = right - mid;
p=L_size;
q=R_size;
int L[p], R[q];
for(i=0; i<p; i++)
{
L[i]=a[left+i];
}
for(i=0; i<q; i++)
{
R[i]=a[mid+1+i];
}
12

13. Code of Merging Function (part-2)
for(k=left; left_index<p&&right_index<q;
k++)
{
if(L[left_index]<R[right_index])
{
a[k]=L[left_index];
left_index++;
}
else
{
a[k]=R[right_index];
right_index++;
}
}
13

14. Code of Merging Function (part-3)
while(left_index<L_size)
{
a[k]=L[left_index];
left_index++;
k++;
}
while(right_index<L_size)
{
a[k]=R[right_index];
right_index++;
k++;
}
}
14

15. Time Complexity of merge sort
Complexity of merge sort is :
Because At the time of dividing we separate them into two halves .
So the complexity of this part is O(log n) .
Then we merge all the element on increasing or decreasing order. So
in this step the complexity of merging is O(n).
So the overall time complexity of merge sort is O(n * log (n) ).
O(n * log(n))
15

16. Effeciency of Merge Sort
The time complexity of bubble sort , selection sort , insertion sort is
equal to O(n*n).
But the time complexity of merge sort is equal to O(n * log n).
So we need less time for sorting by merge than other sort. So this is
very efficient for computer organization as well as algorithm &
data structure .
16

17. 17