C++ Program For Insertion Sort In A Singly Linked List
Last Updated :
28 Apr, 2023
We have discussed Insertion Sort for arrays. In this article we are going to discuss Insertion Sort for linked list.
Below is a simple insertion sort algorithm for a linked list.
1) Create an empty sorted (or result) list.
2) Traverse the given list, do following for every node.
......a) Insert current node in sorted way in sorted or result list.
3) Change head of given linked list to head of sorted (or result) list.
The main step is (2.a) which has been covered in the post Sorted Insert for Singly Linked List
Below is the implementation of the above algorithm:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int val;
struct Node* next;
Node( int x)
{
val = x;
next = NULL;
}
};
class LinkedlistIS
{
public :
Node* head;
Node* sorted;
void push( int val)
{
Node* newnode = new Node(val);
newnode->next = head;
head = newnode;
}
void insertionSort(Node* headref)
{
sorted = NULL;
Node* current = headref;
while (current != NULL)
{
Node* next = current->next;
sortedInsert(current);
current = next;
}
head = sorted;
}
void sortedInsert(Node* newnode)
{
if (sorted == NULL ||
sorted->val >= newnode->val)
{
newnode->next = sorted;
sorted = newnode;
}
else
{
Node* current = sorted;
while (current->next != NULL &&
current->next->val < newnode->val)
{
current = current->next;
}
newnode->next = current->next;
current->next = newnode;
}
}
void printlist(Node* head)
{
while (head != NULL)
{
cout << head->val << " " ;
head = head->next;
}
}
};
int main()
{
LinkedlistIS list;
list.head = NULL;
list.push(5);
list.push(20);
list.push(4);
list.push(3);
list.push(30);
cout << "Linked List before sorting" <<
endl;
list.printlist(list.head);
cout << endl;
list.insertionSort(list.head);
cout << "Linked List After sorting" <<
endl;
list.printlist(list.head);
}
|
Output
Linked List before sorting
30 3 4 20 5
Linked List After sorting
3 4 5 20 30
Time Complexity: O(n2), in the worst case, we might have to traverse all nodes of the sorted list for inserting a node, and there are “n” such nodes.
Auxiliary Space: O(1), no extra space is required depending on the size of the input, thus it is constant.
Please refer complete article on Insertion Sort for Singly Linked List for more details!
Another Approach:
The idea behind this approach is to make use of dummy pointer variable that will store the elements of singly linked list in sorted order. Below is the insertion sort algorithm for singly linked list.
1) Create a new dummy node with a value equals to INT_MIN.
2) Traverse the given list, do following for every node:
a) Create two node pointers curr and prev, curr pointer pointing to dummy node variable and prev to nullptr.
b) Traverse the dummy node list and move pointer curr to its next node and prev to curr uptil the value of
node to which curr pointer is pointing is less than that of the head node value.
c) Create a next pointer which will point to the next of head element.
d) Make prev pointer's next pointing to head node and head node next pointing to curr pointer.
e) Now move head node pointer to its next node.
C++
#include<bits/stdc++.h>
using namespace std;
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode( int x) : val(x), next(nullptr) {}
ListNode( int x, ListNode *next) : val(x), next(next) {}
};
ListNode* insertionSortList(ListNode* head) {
if (!head||!head->next) return head;
ListNode* dummy= new ListNode(INT_MIN);
while (head)
{
ListNode* curr=dummy,*prev=nullptr;
while (curr&&curr->val<=head->val)
{
prev=curr;
curr=curr->next;
}
ListNode* next=head->next;
prev->next=head;
head->next=curr;
head=next;
}
return dummy->next;
}
void printlist(ListNode* head){
while (head != NULL)
{
cout << head->val << " " ;
head = head->next;
}
cout<<endl;
}
int main()
{
ListNode *first= new ListNode(30);
ListNode *second= new ListNode(3);
ListNode *third= new ListNode(4);
ListNode *fourth= new ListNode(20);
ListNode *fifth= new ListNode(5);
first->next=second;
second->next=third;
third->next=fourth;
fourth->next=fifth;
cout << "Linked List before sorting" <<
endl;
printlist(first);
cout << endl;
ListNode* sorted=insertionSortList(first);
cout << "Linked List After sorting" <<
endl;
printlist(sorted);
}
|
Output
Linked List before sorting
30 3 4 20 5
Linked List After sorting
3 4 5 20 30
Time Complexity: O(n2), in the worst case, we might have to traverse all nodes of the sorted list to insert a node, and there are “n” such nodes.
Auxiliary Space: O(1), as the dummy node that we have created takes constant space.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...