 Open in App
Not now

# Insertion Sort for Singly Linked List

• Difficulty Level : Medium
• Last Updated : 10 Jan, 2023

We have discussed Insertion Sort for arrays. In this article, we are going to discuss Insertion Sort for a 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.

Recommended: Please try your approach on {IDE} first, before moving on to the solution

The main step is (2.a) which has been covered in the below post.
Sorted Insert for Singly Linked List

Below is the implementation of the above algorithm

## C

 `// C program to sort link list ` `// using insertion sort ` `#include ` `#include ` ` `  `struct` `node { ` `    ``int` `data; ` `    ``struct` `node* next; ` `}; ` ` `  `struct` `node* head = NULL; ` `struct` `node* sorted = NULL; ` ` `  `void` `push(``int` `val) ` `{ ` `    ``/* allocate node */` `    ``struct` `node* newnode ` `        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node)); ` `    ``newnode->data = val; ` `    ``/* link the old list of the new node */` `    ``newnode->next = head; ` `    ``/* move the head to point to the new node */` `    ``head = newnode; ` `} ` ` `  `/* ` ` ``* function to insert a new_node in a list. Note that ` ` ``* this function expects a pointer to head_ref as this ` ` ``* can modify the head of the input linked list ` ` ``* (similar to push()) ` ` ``*/` `void` `sortedInsert(``struct` `node* newnode) ` `{ ` `    ``/* Special case for the head end */` `    ``if` `(sorted == NULL || sorted->data >= newnode->data) { ` `        ``newnode->next = sorted; ` `        ``sorted = newnode; ` `    ``} ` `    ``else` `{ ` `        ``struct` `node* current = sorted; ` `        ``/* Locate the node before the point of insertion ` `         ``*/` `        ``while` `(current->next != NULL ` `               ``&& current->next->data < newnode->data) { ` `            ``current = current->next; ` `        ``} ` `        ``newnode->next = current->next; ` `        ``current->next = newnode; ` `    ``} ` `} ` ` `  `// function to sort a singly linked list  ` `// using insertion sort ` `void` `insertionsort() ` `{ ` ` `  `    ``struct` `node* current = head; ` ` `  `    ``// Traverse the given linked list and insert every ` `    ``// node to sorted ` `    ``while` `(current != NULL) { ` ` `  `        ``// Store next for next iteration ` `        ``struct` `node* next = current->next; ` ` `  `        ``// insert current in sorted linked list ` `        ``sortedInsert(current); ` ` `  `        ``// Update current ` `        ``current = next; ` `    ``} ` `    ``// Update head to point to sorted linked list ` `    ``head = sorted; ` `} ` ` `  `/* Function to print linked list */` `void` `printlist(``struct` `node* head) ` `{ ` `    ``while` `(head != NULL) { ` `        ``printf``(``"%d->"``, head->data); ` `        ``head = head->next; ` `    ``} ` `    ``printf``(``"NULL"``); ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` ` `  `    ``push(5); ` `    ``push(20); ` `    ``push(4); ` `    ``push(3); ` `    ``push(30); ` ` `  `    ``printf``(``"Linked List before sorting:\n"``); ` `    ``printlist(head); ` `    ``printf``(``"\n"``); ` ` `  `    ``insertionsort(head); ` ` `  `    ``printf``(``"Linked List after sorting:\n"``); ` `    ``printlist(head); ` `} ` ` `  `// This code is contributed by Sornodeep Chandra`

## C++

 `// C++ program to sort link list ` `// using insertion sort ` `#include ` `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) ` `    ``{ ` `        ``/* allocate node */` `        ``Node* newnode = ``new` `Node(val); ` `        ``/* link the old list of the new node */` `        ``newnode->next = head; ` `        ``/* move the head to point to the new node */` `        ``head = newnode; ` `    ``} ` ` `  `    ``// function to sort a singly linked list using insertion ` `    ``// sort ` `    ``void` `insertionSort(Node* headref) ` `    ``{ ` `        ``// Initialize sorted linked list ` `        ``sorted = NULL; ` `        ``Node* current = headref; ` `        ``// Traverse the given linked list and insert every ` `        ``// node to sorted ` `        ``while` `(current != NULL) { ` `            ``// Store next for next iteration ` `            ``Node* next = current->next; ` `            ``// insert current in sorted linked list ` `            ``sortedInsert(current); ` `            ``// Update current ` `            ``current = next; ` `        ``} ` `        ``// Update head_ref to point to sorted linked list ` `        ``head = sorted; ` `    ``} ` ` `  `    ``/* ` `     ``* function to insert a new_node in a list. Note that ` `     ``* this function expects a pointer to head_ref as this ` `     ``* can modify the head of the input linked list ` `     ``* (similar to push()) ` `     ``*/` `    ``void` `sortedInsert(Node* newnode) ` `    ``{ ` `        ``/* Special case for the head end */` `        ``if` `(sorted == NULL || sorted->val >= newnode->val) { ` `            ``newnode->next = sorted; ` `            ``sorted = newnode; ` `        ``} ` `        ``else` `{ ` `            ``Node* current = sorted; ` `            ``/* Locate the node before the point of insertion ` `             ``*/` `            ``while` `(current->next != NULL ` `                   ``&& current->next->val < newnode->val) { ` `                ``current = current->next; ` `            ``} ` `            ``newnode->next = current->next; ` `            ``current->next = newnode; ` `        ``} ` `    ``} ` `    ``/* Function to print linked list */` `    ``void` `printlist(Node* head) ` `    ``{ ` `        ``while` `(head != NULL) { ` `            ``cout << head->val << ``" "``; ` `            ``head = head->next; ` `        ``} ` `    ``} ` `}; ` `// Driver program to test above functions ` `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); ` `} ` ` `  `// This code is contributed by nirajgusain5`

## Java

 `// Java program to sort link list ` `// using insertion sort ` ` `  `public` `class` `LinkedlistIS  ` `{ ` `    ``node head; ` `    ``node sorted; ` ` `  `    ``class` `node  ` `    ``{ ` `        ``int` `val; ` `        ``node next; ` ` `  `        ``public` `node(``int` `val)  ` `        ``{ ` `            ``this``.val = val; ` `        ``} ` `    ``} ` ` `  `    ``void` `push(``int` `val)  ` `    ``{ ` `        ``/* allocate node */` `        ``node newnode = ``new` `node(val); ` `        ``/* link the old list of the new node */` `        ``newnode.next = head; ` `        ``/* move the head to point to the new node */` `        ``head = newnode; ` `    ``} ` ` `  `    ``// function to sort a singly linked list using insertion sort ` `    ``void` `insertionSort(node headref)  ` `    ``{ ` `        ``// Initialize sorted linked list ` `        ``sorted = ``null``; ` `        ``node current = headref; ` `        ``// Traverse the given linked list and insert every ` `        ``// node to sorted ` `        ``while` `(current != ``null``)  ` `        ``{ ` `            ``// Store next for next iteration ` `            ``node next = current.next; ` `            ``// insert current in sorted linked list ` `            ``sortedInsert(current); ` `            ``// Update current ` `            ``current = next; ` `        ``} ` `        ``// Update head_ref to point to sorted linked list ` `        ``head = sorted; ` `    ``} ` ` `  `    ``/* ` `     ``* function to insert a new_node in a list. Note that  ` `     ``* this function expects a pointer to head_ref as this ` `     ``* can modify the head of the input linked list  ` `     ``* (similar to push()) ` `     ``*/` `    ``void` `sortedInsert(node newnode)  ` `    ``{ ` `        ``/* Special case for the head end */` `        ``if` `(sorted == ``null` `|| sorted.val >= newnode.val)  ` `        ``{ ` `            ``newnode.next = sorted; ` `            ``sorted = newnode; ` `        ``} ` `        ``else`  `        ``{ ` `            ``node current = sorted; ` `            ``/* Locate the node before the point of insertion */` `            ``while` `(current.next != ``null` `&& current.next.val < newnode.val)  ` `            ``{ ` `                ``current = current.next; ` `            ``} ` `            ``newnode.next = current.next; ` `            ``current.next = newnode; ` `        ``} ` `    ``} ` ` `  `    ``/* Function to print linked list */` `    ``void` `printlist(node head)  ` `    ``{ ` `        ``while` `(head != ``null``)  ` `        ``{ ` `            ``System.out.print(head.val + ``" "``); ` `            ``head = head.next; ` `        ``} ` `    ``} ` `     `  `    ``// Driver program to test above functions ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``LinkedlistIS list = ``new` `LinkedlistIS(); ` `        ``list.push(``5``); ` `        ``list.push(``20``); ` `        ``list.push(``4``); ` `        ``list.push(``3``); ` `        ``list.push(``30``); ` `        ``System.out.println(``"Linked List before Sorting.."``); ` `        ``list.printlist(list.head); ` `        ``list.insertionSort(list.head); ` `        ``System.out.println(``"\nLinkedList After sorting"``); ` `        ``list.printlist(list.head); ` `    ``} ` `} ` ` `  `// This code is contributed by Rishabh Mahrsee `

## Python

 `# Python implementation of above algorithm ` ` `  `# Node class  ` `class` `Node:  ` `     `  `    ``# Constructor to initialize the node object  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.``next` `=` `None` ` `  `# function to sort a singly linked list using insertion sort ` `def` `insertionSort(head_ref): ` ` `  `    ``# Initialize sorted linked list ` `    ``sorted` `=` `None` ` `  `    ``# Traverse the given linked list and insert every ` `    ``# node to sorted ` `    ``current ``=` `head_ref ` `    ``while` `(current !``=` `None``): ` `     `  `        ``# Store next for next iteration ` `        ``next` `=` `current.``next` ` `  `        ``# insert current in sorted linked list ` `        ``sorted` `=` `sortedInsert(``sorted``, current) ` ` `  `        ``# Update current ` `        ``current ``=` `next` `     `  `    ``# Update head_ref to point to sorted linked list ` `    ``head_ref ``=` `sorted` `    ``return` `head_ref ` ` `  `# function to insert a new_node in a list. Note that this ` `# function expects a pointer to head_ref as this can modify the ` `# head of the input linked list (similar to push()) ` `def` `sortedInsert(head_ref, new_node): ` ` `  `    ``current ``=` `None` `     `  `    ``# Special case for the head end */ ` `    ``if` `(head_ref ``=``=` `None` `or` `(head_ref).data >``=` `new_node.data): ` `     `  `        ``new_node.``next` `=` `head_ref ` `        ``head_ref ``=` `new_node ` `     `  `    ``else``: ` `     `  `        ``# Locate the node before the point of insertion  ` `        ``current ``=` `head_ref ` `        ``while` `(current.``next` `!``=` `None` `and` `            ``current.``next``.data < new_node.data): ` `         `  `            ``current ``=` `current.``next` `         `  `        ``new_node.``next` `=` `current.``next` `        ``current.``next` `=` `new_node ` `         `  `    ``return` `head_ref ` ` `  `# BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert  ` ` `  `# Function to print linked list */ ` `def` `printList(head): ` ` `  `    ``temp ``=` `head ` `    ``while``(temp !``=` `None``): ` `     `  `        ``print``( temp.data, end ``=` `" "``) ` `        ``temp ``=` `temp.``next` `     `  `# A utility function to insert a node ` `# at the beginning of linked list  ` `def` `push( head_ref, new_data): ` ` `  `    ``# allocate node ` `    ``new_node ``=` `Node(``0``) ` ` `  `    ``# put in the data  ` `    ``new_node.data ``=` `new_data ` ` `  `    ``# link the old list of the new node  ` `    ``new_node.``next` `=` `(head_ref) ` ` `  `    ``# move the head to point to the new node  ` `    ``(head_ref) ``=` `new_node ` `    ``return` `head_ref ` ` `  `# Driver program to test above functions ` ` `  `a ``=` `None` `a ``=` `push(a, ``5``) ` `a ``=` `push(a, ``20``) ` `a ``=` `push(a, ``4``) ` `a ``=` `push(a, ``3``) ` `a ``=` `push(a, ``30``) ` ` `  `print``(``"Linked List before sorting "``) ` `printList(a) ` ` `  `a ``=` `insertionSort(a) ` ` `  `print``(``"\nLinked List after sorting "``) ` `printList(a) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# program to sort link list ` `// using insertion sort ` `using` `System; ` ` `  `public` `class` `LinkedlistIS  ` `{ ` `    ``public` `node head; ` `    ``public` `node sorted; ` ` `  `    ``public` `class` `node  ` `    ``{ ` `        ``public` `int` `val; ` `        ``public` `node next; ` ` `  `        ``public` `node(``int` `val)  ` `        ``{ ` `            ``this``.val = val; ` `        ``} ` `    ``} ` ` `  `    ``void` `push(``int` `val)  ` `    ``{ ` `        ``/* allocate node */` `        ``node newnode = ``new` `node(val); ` `         `  `        ``/* link the old list of the new node */` `        ``newnode.next = head; ` `         `  `        ``/* move the head to point to the new node */` `        ``head = newnode; ` `    ``} ` ` `  `    ``// function to sort a singly  ` `    ``// linked list using insertion sort ` `    ``void` `insertionSort(node headref)  ` `    ``{ ` `        ``// Initialize sorted linked list ` `        ``sorted = ``null``; ` `        ``node current = headref; ` `         `  `        ``// Traverse the given  ` `        ``// linked list and insert every ` `        ``// node to sorted ` `        ``while` `(current != ``null``)  ` `        ``{ ` `            ``// Store next for next iteration ` `            ``node next = current.next; ` `             `  `            ``// insert current in sorted linked list ` `            ``sortedInsert(current); ` `             `  `            ``// Update current ` `            ``current = next; ` `        ``} ` `         `  `        ``// Update head_ref to point to sorted linked list ` `        ``head = sorted; ` `    ``} ` ` `  `    ``/* ` `    ``* function to insert a new_node in a list. Note that  ` `    ``* this function expects a pointer to head_ref as this ` `    ``* can modify the head of the input linked list  ` `    ``* (similar to push()) ` `    ``*/` `    ``void` `sortedInsert(node newnode)  ` `    ``{ ` `        ``/* Special case for the head end */` `        ``if` `(sorted == ``null` `|| sorted.val >= newnode.val)  ` `        ``{ ` `            ``newnode.next = sorted; ` `            ``sorted = newnode; ` `        ``} ` `        ``else` `        ``{ ` `            ``node current = sorted; ` `             `  `            ``/* Locate the node before the point of insertion */` `            ``while` `(current.next != ``null` `&&  ` `                    ``current.next.val < newnode.val)  ` `            ``{ ` `                ``current = current.next; ` `            ``} ` `            ``newnode.next = current.next; ` `            ``current.next = newnode; ` `        ``} ` `    ``} ` ` `  `    ``/* Function to print linked list */` `    ``void` `printlist(node head)  ` `    ``{ ` `        ``while` `(head != ``null``)  ` `        ``{ ` `            ``Console.Write(head.val + ``" "``); ` `            ``head = head.next; ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``LinkedlistIS list = ``new` `LinkedlistIS(); ` `        ``list.push(5); ` `        ``list.push(20); ` `        ``list.push(4); ` `        ``list.push(3); ` `        ``list.push(30); ` `        ``Console.WriteLine(``"Linked List before Sorting.."``); ` `        ``list.printlist(list.head); ` `        ``list.insertionSort(list.head); ` `        ``Console.WriteLine(``"\nLinkedList After sorting"``); ` `        ``list.printlist(list.head); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

## Javascript

 ` `

Output:

```Linked List before sorting
30  3  4  20  5
3  4  5  20  30```

#### Time and space complexity analysis:

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.

Thus Time Complexity: O(n)*O(n)=O(n^2)

Space Complexity: No extra space is required depending on the size of the input. Thus Space complexity is constant- O(1).