# C++ Program to Implement Merge Sort Algorithm on Linked List

C++Server Side ProgrammingProgramming

#### C in Depth: The Complete C Programming Guide for Beginners

45 Lectures 4.5 hours

#### Practical C++: Learn C++ Basics Step by Step

Most Popular

50 Lectures 4.5 hours

#### Master C and Embedded C Programming- Learn as you go

66 Lectures 5.5 hours

The merge sort technique is based on divide and conquer technique. We divide the while data set 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 worst case also.

Linked list can be sorted using merge-sort very efficiently. For the linked list the merging task is very simple. We can simply update the links to merge them. In this section we will see how to sort the linked list using this approach.

## The complexity of Merge Sort Technique

• Time Complexity − O(n log n) for all cases

• Space Complexity − O(n)

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

## Algorithm

### mergeList(ll1, ll2)

Input − It takes two linked lists ll1 and ll2

Output − The merged list

Begin
if ll1 is empty, then
return ll2
if ll2 is empty, then
return ll1
if data(ll1) <= data(ll2), then
next(new_head) = mergeList(next(ll1), ll2)
else
next(new_head) = mergeList(ll1, next(ll2))
End

### split_list(start, ll1, ll2)

Input − The start pointer of a linked list, two output arguments ll1 and ll2

Output − Two linked list generated from the linked list

Begin
slow := start
fast := next(start)
while fast is not null, do
fast := next(fast)
if fast is not null, then
slow := next(slow)
fast := next(fast)
end while
ll1 := start
ll2 := next(slow)
next(slow) := null
End

### mergeSort(start)

Input − The linked list

Output − Sorted linked list

Begin
if head is null or next(head) is null, then
return
mergeSort(ll1)
mergeSort(ll2)
start := mergeList(ll1, ll2)
End

## Source Code (C++)

Live Demo

#include<bits/stdc++.h>
using namespace std;
class node { //define node to store data and next address
public:
int data;
node *next;
};
void display(class node* start) {
node* p = start; // current node set to head
while(p != NULL) { //traverse until current node isn't NULL
cout << p -> data << " ";
p = p -> next; // go to next node
}
}
node* getNode(int d) {
node* temp = new node;
temp -> data = d;
temp -> next = NULL;
return temp;
}
node* mergeList(node* ll1, node* ll2) { //function for merging two sorted list
node* newhead = NULL;
if(ll1 == NULL)
return ll2;
if(ll2 == NULL)
return ll1;
//recursively merge the lists
if(ll1 -> data <= ll2 -> data) {
newhead -> next = mergeList(ll1->next,ll2);
} else {
newhead -> next = mergeList(ll1,ll2->next);
}
}
void splitList(node* start, node** ll1,node** ll2) {
//similar to flyod's tortoise algorithm
node* slow = start;
node* fast = start -> next;
while(fast!= NULL) {
fast = fast -> next;
if(fast!= NULL) {
slow = slow -> next;
fast = fast -> next;
}
}
*ll1 = start;
*ll2 = slow -> next;
//spliting
slow -> next = NULL;
}
void mergeSort(node** start) {
node* head = *start;
node* ll1,*ll2;
//base case
if(head == NULL || head->next == NULL) {
return;
}
splitList(head,&ll1,&ll2); //split the list in two halves
//sort left and right sublists
mergeSort(&ll1);
mergeSort(&ll2);
//merge two sorted list
*start = mergeList(ll1,ll2);
return;
}
int main() {
cout << "Creating the linked list: " << endl;
cout << "Enter 0 to stop building the list, else enter any integer" << endl;
int k,count = 1,x;
node* curr,*temp;
cin >> k;
node* head = getNode(k);   //buliding list, first node
cin >> k;
while(k) {
curr = getNode(k);
temp -> next = curr;//appending each node
temp = temp -> next;
cin >> k;
}
cout<<"Before sorting: " << endl;
display(head); // displaying the list
cout<<"\nAfter sorting: " << endl;
return 0;
}

## Output

Creating the linked list:
Enter 0 to stop building the list, else enter any integer
89
54
15
64
74
98
10
24
26
0
Before sorting:
89 54 15 64 74 98 10 24 26
After sorting:
10 15 24 26 54 64 74 89 98