Merge Sort - Javatpoint
Merge Sort - Javatpoint
Merge Sort - Javatpoint
Merge sort is similar to the quick sort algorithm as it uses the divide and conquer approach to sort
the elements. It is one of the most popular and efficient sorting algorithm. It divides the given list
into two equal halves, calls itself for the two halves and then merges the two sorted halves. We have
to define the merge() function to perform the merging.
The sub-lists are divided again and again into halves until the list cannot be divided further. Then we
combine the pair of one element lists into two-element lists, sorting them in the process. The sorted
two-element pairs is merged into the four-element lists, and so on until we get the sorted list.
Algorithm
In the following algorithm, arr is the given array, beg is the starting element, and end is the last
element of the array.
MERGE_SORT(arr, beg, end)
if beg < end
set mid = (beg + end)/2
MERGE_SORT(arr, beg, mid)
MERGE_SORT(arr, mid + 1, end)
MERGE (arr, beg, mid, end)
https://www.javatpoint.com/merge-sort 2/23
07/12/2022, 11:30 Merge Sort - javatpoint
end of if
END MERGE_SORT
The important part of the merge sort is the MERGE function. This function performs the merging of
two sorted sub-arrays that are A[beg…mid] and A[mid+1…end], to build one sorted array
A[beg…end]. So, the inputs of the MERGE function are A[], beg, mid, and end.
/* Function to merge the subarrays of a[] */
void merge(int a[], int beg, int mid, int end)
{
int i, j, k;
int n1 = mid - beg + 1;
int n2 = end - mid;
int LeftArray[n1], RightArray[n2]; //temporary arrays
/* copy data to temp arrays */
for (int i = 0; i < n1; i++)
LeftArray[i] = a[beg + i];
for (int j = 0; j < n2; j++)
RightArray[j] = a[mid + 1 + j];
i = 0, /* initial index of first sub-array */
j = 0; /* initial index of second sub-array */
k = beg; /* initial index of merged sub-array */
while (i < n1 && j < n2)
{
if(LeftArray[i] <= RightArray[j])
{
a[k] = LeftArray[i];
i++;
}
else
{
a[k] = RightArray[j];
https://www.javatpoint.com/merge-sort 3/23
07/12/2022, 11:30 Merge Sort - javatpoint
j++;
}
k++;
}
while (i<n1)
{
a[k] = LeftArray[i];
i++;
k++;
}
while (j<n2)
{
a[k] = RightArray[j];
j++;
k++;
}
}
To understand the working of the merge sort algorithm, let's take an unsorted array. It will be easier
to understand the merge sort via an example.
According to the merge sort, first divide the given array into two equal halves. Merge sort keeps
dividing the list into equal parts until it cannot be further divided.
As there are eight elements in the given array, so it is divided into two arrays of size 4.
https://www.javatpoint.com/merge-sort 4/23
07/12/2022, 11:30 Merge Sort - javatpoint
Ads by
Stop seeing this ad Why this ad?
Remote Jobs At Atlassian
At Atlassian you can work from home, an office, or in
between — you can choose.
Atlassian Open
Now, again divide these two arrays into halves. As they are of size 4, so divide them into new arrays
of size 2.
Now, again divide these arrays to get the atomic value that cannot be further divided.
In combining, first compare the element of each array and then combine them into another array in
sorted order.
So, first compare 12 and 31, both are in sorted positions. Then compare 25 and 8, and in the list of
two values, put 8 first followed by 25. Then compare 32 and 17, sort them and put 17 first followed
by 32. After that, compare 40 and 42, and place them sequentially.
https://www.javatpoint.com/merge-sort 5/23
07/12/2022, 11:30 Merge Sort - javatpoint
Sponsored
In the next iteration of combining, now compare the arrays with two data values and merge them
into an array of found values in sorted order.
Now, there is a final merging of the arrays. After the final merging of above arrays, the array will look
like -
https://www.javatpoint.com/merge-sort 6/23
07/12/2022, 11:30 Merge Sort - javatpoint
1. Time Complexity
Best Case Complexity - It occurs when there is no sorting required, i.e. the array is already
sorted. The best-case time complexity of merge sort is O(n*logn).
Average Case Complexity - It occurs when the array elements are in jumbled order that is
not properly ascending and not properly descending. The average case time complexity of
merge sort is O(n*logn).
Worst Case Complexity - It occurs when the array elements are required to be sorted in
reverse order. That means suppose you have to sort the array elements in ascending order,
but its elements are in descending order. The worst-case time complexity of merge sort is
O(n*logn).
2. Space Complexity
Stable YES
The space complexity of merge sort is O(n). It is because, in merge sort, an extra variable is
required for swapping.
#include <stdio.h>
/* Function to merge the subarrays of a[] */
void merge(int a[], int beg, int mid, int end)
{
int i, j, k;
https://www.javatpoint.com/merge-sort 7/23
07/12/2022, 11:30 Merge Sort - javatpoint
int n1 = mid - beg + 1;
int n2 = end - mid;
int LeftArray[n1], RightArray[n2]; //temporary arrays
/* copy data to temp arrays */
for (int i = 0; i < n1; i++)
LeftArray[i] = a[beg + i];
for (int j = 0; j < n2; j++)
RightArray[j] = a[mid + 1 + j];
i = 0; /* initial index of first sub-array */
j = 0; /* initial index of second sub-array */
k = beg; /* initial index of merged sub-array */
while (i < n1 && j < n2)
{
if(LeftArray[i] <= RightArray[j])
{
a[k] = LeftArray[i];
i++;
}
else
{
a[k] = RightArray[j];
j++;
}
k++;
}
while (i<n1)
{
a[k] = LeftArray[i];
i++;
k++;
}
while (j<n2)
{
https://www.javatpoint.com/merge-sort 8/23
07/12/2022, 11:30 Merge Sort - javatpoint
a[k] = RightArray[j];
j++;
k++;
}
}
void mergeSort(int a[], int beg, int end)
{
if (beg < end)
{
int mid = (beg + end) / 2;
mergeSort(a, beg, mid);
mergeSort(a, mid + 1, end);
merge(a, beg, mid, end);
}
}
/* Function to print the array */
void printArray(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", a[i]);
printf("\n");
}
int main()
{
int a[] = { 12, 31, 25, 8, 32, 17, 40, 42 };
int n = sizeof(a) / sizeof(a[0]);
printf("Before sorting array elements are - \n");
printArray(a, n);
mergeSort(a, 0, n - 1);
printf("After sorting array elements are - \n");
printArray(a, n);
return 0;
}
https://www.javatpoint.com/merge-sort 9/23
07/12/2022, 11:30 Merge Sort - javatpoint
Output:
#include <iostream>
using namespace std;
/* Function to merge the subarrays of a[] */
void merge(int a[], int beg, int mid, int end)
{
int i, j, k;
int n1 = mid - beg + 1;
int n2 = end - mid;
int LeftArray[n1], RightArray[n2]; //temporary arrays
/* copy data to temp arrays */
for (int i = 0; i < n1; i++)
LeftArray[i] = a[beg + i];
for (int j = 0; j < n2; j++)
RightArray[j] = a[mid + 1 + j];
i = 0; /* initial index of first sub-array */
j = 0; /* initial index of second sub-array */
k = beg; /* initial index of merged sub-array */
while (i < n1 && j < n2)
{
if(LeftArray[i] <= RightArray[j])
{
a[k] = LeftArray[i];
i++;
}
else
https://www.javatpoint.com/merge-sort 10/23
07/12/2022, 11:30 Merge Sort - javatpoint
{
a[k] = RightArray[j];
j++;
}
k++;
}
while (i<n1)
{
a[k] = LeftArray[i];
i++;
k++;
}
while (j<n2)
{
a[k] = RightArray[j];
j++;
k++;
}
}
void mergeSort(int a[], int beg, int end)
{
if (beg < end)
{
int mid = (beg + end) / 2;
mergeSort(a, beg, mid);
mergeSort(a, mid + 1, end);
merge(a, beg, mid, end);
}
}
/* Function to print the array */
void printArray(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
cout<<a[i]<<" ";
https://www.javatpoint.com/merge-sort 11/23
07/12/2022, 11:30 Merge Sort - javatpoint
}
int main()
{
int a[] = { 11, 30, 24, 7, 31, 16, 39, 41 };
int n = sizeof(a) / sizeof(a[0]);
cout<<"Before sorting array elements are - \n";
printArray(a, n);
mergeSort(a, 0, n - 1);
cout<<"\nAfter sorting array elements are - \n";
printArray(a, n);
return 0;
}
Output:
class Merge {
/* Function to merge the subarrays of a[] */
void merge(int a[], int beg, int mid, int end)
{
int i, j, k;
int n1 = mid - beg + 1;
int n2 = end - mid;
/* temporary Arrays */
int LeftArray[] = new int[n1];
int RightArray[] = new int[n2];
/* copy data to temp arrays */
for (i = 0; i < n1; i++)
LeftArray[i] = a[beg + i];
for (j = 0; j < n2; j++)
https://www.javatpoint.com/merge-sort 12/23
07/12/2022, 11:30 Merge Sort - javatpoint
RightArray[j] = a[mid + 1 + j];
i = 0; /* initial index of first sub-array */
j = 0; /* initial index of second sub-array */
k = beg; /* initial index of merged sub-array */
while (i < n1 && j < n2)
{
if(LeftArray[i] <= RightArray[j])
{
a[k] = LeftArray[i];
i++;
}
else
{
a[k] = RightArray[j];
j++;
}
k++;
}
while (i<n1)
{
a[k] = LeftArray[i];
i++;
k++;
}
while (j<n2)
{
a[k] = RightArray[j];
j++;
k++;
}
}
void mergeSort(int a[], int beg, int end)
{
if (beg < end)
https://www.javatpoint.com/merge-sort 13/23
07/12/2022, 11:30 Merge Sort - javatpoint
{
int mid = (beg + end) / 2;
mergeSort(a, beg, mid);
mergeSort(a, mid + 1, end);
merge(a, beg, mid, end);
}
}
/* Function to print the array */
void printArray(int a[], int n)
{
int i;
for (i = 0; i < n; i++)
System.out.print(a[i] + " ");
}
public static void main(String args[])
{
int a[] = { 11, 30, 24, 7, 31, 16, 39, 41 };
int n = a.length;
Merge m1 = new Merge();
System.out.println("\nBefore sorting array elements are - ");
m1.printArray(a, n);
m1.mergeSort(a, 0, n - 1);
System.out.println("\nAfter sorting array elements are - ");
m1.printArray(a, n);
System.out.println("");
}
}
Output:
Ads by
Stop seeing this ad Why this ad?
Remote Jobs At Atlassian
Atlassian Open
using System;
class Merge {
/* Function to merge the subarrays of a[] */
static void merge(int[] a, int beg, int mid, int end)
{
int i, j, k;
int n1 = mid - beg + 1;
int n2 = end - mid;
//temporary arrays
int[] LeftArray = new int [n1];
int[] RightArray = new int [n2];
/* copy data to temp arrays */
for (i = 0; i < n1; i++)
LeftArray[i] = a[beg + i];
for (j = 0; j < n2; j++)
RightArray[j] = a[mid + 1 + j];
i = 0; /* initial index of first sub-array */
j = 0; /* initial index of second sub-array */
k = beg; /* initial index of merged sub-array */
while (i < n1 && j < n2)
{
if(LeftArray[i] <= RightArray[j])
https://www.javatpoint.com/merge-sort 15/23
07/12/2022, 11:30 Merge Sort - javatpoint
{
a[k] = LeftArray[i];
i++;
}
else
{
a[k] = RightArray[j];
j++;
}
k++;
}
while (i<n1)
{
a[k] = LeftArray[i];
i++;
k++;
}
while (j<n2)
{
a[k] = RightArray[j];
j++;
k++;
}
}
static void mergeSort(int[] a, int beg, int end)
{
if (beg < end)
{
int mid = (beg + end) / 2;
mergeSort(a, beg, mid);
mergeSort(a, mid + 1, end);
merge(a, beg, mid, end);
}
}
/* Function to print the array */
https://www.javatpoint.com/merge-sort 16/23
07/12/2022, 11:30 Merge Sort - javatpoint
static void printArray(int[] a, int n)
{
int i;
for (i = 0; i < n; i++)
Console.Write(a[i] + " ");
}
static void Main()
{
int[] a = { 10, 29, 23, 6, 30, 15, 38, 40 };
int n = a.Length;
Console.Write("Before sorting array elements are - ");
printArray(a, n);
mergeSort(a, 0, n - 1);
Console.Write("\nAfter sorting array elements are - ");
printArray(a, n);
}
}
Output:
<?php
/* Function to merge the subarrays of a[] */
function merge(&$a, $beg, $mid, $end)
{
$n1 = ($mid - $beg) + 1;
$n2 = $end - $mid;
/* temporary Arrays */
$LeftArray = array($n1);
$RightArray = array($n2);
https://www.javatpoint.com/merge-sort 17/23
07/12/2022, 11:30 Merge Sort - javatpoint
/* copy data to temp arrays */
for ($i = 0; $i < $n1; $i++)
$LeftArray[$i] = $a[$beg + $i];
for ($j = 0; $j < $n2; $j++)
$RightArray[$j] = $a[$mid + 1 + $j];
$i = 0; /* initial index of first sub-array */
$j = 0; /* initial index of second sub-array */
$k = $beg; /* initial index of merged sub-array */
while ($i<$n1 && $j<$n2)
{
if($LeftArray[$i] <= $RightArray[$j])
{
$a[$k] = $LeftArray[$i];
$i++;
}
else
{
$a[$k] = $RightArray[$j];
$j++;
}
$k++;
}
while ($i<$n1)
{
$a[$k] = $LeftArray[$i];
$i++;
$k++;
}
while ($j<$n2)
{
$a[$k] = $RightArray[$j];
$j++;
$k++;
}
}
https://www.javatpoint.com/merge-sort 18/23
07/12/2022, 11:30 Merge Sort - javatpoint
function mergeSort(&$a, $beg, $end)
{
if ($beg < $end)
{
$mid = (int)(($beg + $end) / 2);
mergeSort($a, $beg, $mid);
mergeSort($a, $mid + 1, $end);
merge($a, $beg, $mid, $end);
}
}
/* Function to print array elements */
function printArray($a, $n)
{
for($i = 0; $i < $n; $i++)
{
print_r($a[$i]);
echo " ";
}
}
$a = array( 10, 29, 23, 6, 30, 15, 38, 40 );
$n = count($a);
echo "Before sorting array elements are - <br>";
printArray($a, $n);
mergeSort($a, 0, $n - 1);
echo "<br> After sorting array elements are - <br>";
printArray($a, $n);
?>
Output:
So, that's all about the article. Hope the article will be helpful and informative to you.
https://www.javatpoint.com/merge-sort 19/23
07/12/2022, 11:30 Merge Sort - javatpoint
This article was not only limited to the algorithm. We have also discussed the Merge sort complexity,
working, and implementation in different programming languages.
← Prev Next →
Atlassian Open
Feedback
https://www.javatpoint.com/merge-sort 20/23