Merge Sort

The merge sort technique is based on divide and conquers technique. We divide the whole dataset into smaller parts and merge them into a larger piece in sorted order. It is also very effective for worst cases because this algorithm has lower time complexity for the worst case also.

The complexity of Merge Sort Technique

• Time Complexity: O(n log n) for all cases
• Space Complexity: O(n)

Input and Output

Input:
The unsorted list: 14 20 78 98 20 45
Output:
Array before Sorting: 14 20 78 98 20 45
Array after Sorting: 14 20 20 45 78 98

Algorithm

merge(array, left, middle, right)

Input − The data set array, left, middle and right index

Output − The merged list

Begin
nLeft := m - left+1
nRight := right – m
define arrays leftArr and rightArr of size nLeft and nRight respectively

for i := 0 to nLeft do
leftArr[i] := array[left +1]
done

for j := 0 to nRight do
rightArr[j] := array[middle + j +1]
done

i := 0, j := 0, k := left
while i < nLeft AND j < nRight do
if leftArr[i] <= rightArr[j] then
array[k] = leftArr[i]
i := i+1
else
array[k] = rightArr[j]
j := j+1
k := k+1
done

while i < nLeft do
array[k] := leftArr[i]
i := i+1
k := k+1
done

while j < nRight do
array[k] := rightArr[j]
j := j+1
k := k+1
done
End

mergeSort(array, left, right)

Input − An array of data, and lower and upper bound of the array

Output − The sorted Array

Begin
if lower < right then
mid := left + (right - left) /2
mergeSort(array, left, mid)
mergeSort (array, mid+1, right)
merge(array, left, mid, right)
End

Example

#include<iostream>
using namespace std;

void swapping(int &a, int &b) { //swap the content of a and b
int temp;
temp = a;
a = b;
b = temp;
}

void display(int *array, int size) {
for(int i = 0; i<size; i++)
cout << array[i] << " ";
cout << endl;
}

void merge(int *array, int l, int m, int r) {
int i, j, k, nl, nr;
//size of left and right sub-arrays
nl = m-l+1; nr = r-m;
int larr[nl], rarr[nr];

//fill left and right sub-arrays
for(i = 0; i<nl; i++)
larr[i] = array[l+i];
for(j = 0; j<nr; j++)
rarr[j] = array[m+1+j];

i = 0; j = 0; k = l;
//marge temp arrays to real array

while(i < nl && j<nr) {
if(larr[i] <= rarr[j]) {
array[k] = larr[i];
i++;
}else{
array[k] = rarr[j];
j++;
}
k++;
}

while(i<nl) {       //extra element in left array
array[k] = larr[i];
i++; k++;
}

while(j<nr) {      //extra element in right array
array[k] = rarr[j];
j++; k++;
}
}

void mergeSort(int *array, int l, int r) {
int m;
if(l < r) {
int m = l+(r-l)/2;
// Sort first and second arrays
mergeSort(array, l, m);
mergeSort(array, m+1, r);
merge(array, l, m, r);
}
}

int main() {
int n;
cout << "Enter the number of elements: ";
cin >> n;
int arr[n]; //create an array with given number of elements
cout << "Enter elements:" << endl;

for(int i = 0; i<n; i++) {
cin >> arr[i];
}

cout << "Array before Sorting: ";
display(arr, n);
mergeSort(arr, 0, n-1); //(n-1) for last index
cout << "Array after Sorting: ";
display(arr, n);
}

Output

Enter the number of elements: 6
Enter elements:
14 20 78 98 20 45
Array before Sorting: 14 20 78 98 20 45
Array after Sorting: 14 20 20 45 78 98