Insertion Sort for Doubly Linked List

Last Updated : 17 Sep, 2024

Given a doubly linked list, the task is to sort the doubly linked list in non-decreasing order using the insertion sort.

Examples:

Input: head: 5<->3<->4<->1<->2
Output: 1<->2<->3<->4<->5
Explanation: Doubly Linked List after sorting using insertion sort technique is 1<->2<->3<->4<->5
Input: head: 1<->5<->2<->3
Output: 1<->2<->3<->5
Explanation: Doubly Linked List after sorting using insertion sort technique is 1<->2<->3<->5

Approach:

The insertion sort algorithm for a doubly linked list works by repeatedly inserting nodes into a sorted portion of the list. It starts with an empty sorted list and iterates through each node in the unsorted part. For each node, it finds the correct position in the sorted portion by comparing with nodes in the sorted list. The node is then inserted into its correct place, adjusting the pointers accordingly. This process continues until all nodes are placed in the sorted list.

Below is the implementation of the above approach:

C++

// C++ program to sort a doubly linked list 
// using insertion sort
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node* prev;

    Node(int x) {
        data = x;
        next = nullptr;
        prev = nullptr;
    }
};

// Function to sort the doubly linked list 
// using insertion sort
Node* insertionSort(Node* head) {
    if (head == nullptr) return head;

    Node* sorted = nullptr;
    Node* curr = head;

    // Traverse the list to sort each element
    while (curr != nullptr) {
      
        // Store the next node to process
        Node* next = curr->next;

        // Insert `curr` into the sorted part
        if (sorted == nullptr || 
                      sorted->data >= curr->data) {
            curr->next = sorted;

            // If sorted is not empty, set its `prev`
            if (sorted != nullptr) sorted->prev = curr;

            // Update sorted to the new head
            sorted = curr;
            sorted->prev = nullptr;

        } 
       else {
          
            // Pointer to traverse the sorted part
            Node* current_sorted = sorted;

            // Find the correct position to insert
            while (current_sorted->next != nullptr &&
                   current_sorted->next->data < curr->data) {
                current_sorted = current_sorted->next;
            }

            // Insert `curr` after `current_sorted`
            curr->next = current_sorted->next;

            // Set `prev` if `curr` is not inserted 
            // at the end
            if (current_sorted->next != nullptr) 
                current_sorted->next->prev = curr;

            // Set `next` of `current_sorted` to `curr`
            current_sorted->next = curr;
            curr->prev = current_sorted;
        }

        // Move to the next node to be sorted
        curr = next;
    }

    return sorted;
}

void printList(Node* node) {
    Node* curr = node;
    while (curr != nullptr) {
        cout << " " << curr->data;
        curr = curr->next;
    }
}

int main() {
  
    // Create a hard-coded doubly linked list:
    // 5 <-> 3 <-> 4 <-> 1 <-> 2
    Node* head = new Node(5);
    head->next = new Node(3);
    head->next->prev = head;
    head->next->next = new Node(4);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(1);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = new Node(2);
    head->next->next->next->next->prev
                     = head->next->next->next;

    head = insertionSort(head);

    printList(head);

    return 0;
}

// C program to sort a doubly linked list
// using insertion sort
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};

// Function to sort the doubly linked list using
// insertion sort
struct Node* insertionSort(struct Node* head) {
  
    if (head == NULL) return head;
    struct Node* sorted = NULL;
    struct Node* curr = head;

    // Traverse the list to sort each element
    while (curr != NULL) {
      
        // Store the next node to process
        struct Node* next = curr->next;

        // Insert `curr` into the sorted part
        if (sorted == NULL || sorted->data >= curr->data) {
            curr->next = sorted;

            // If sorted is not empty, set its `prev`
            if (sorted != NULL) sorted->prev = curr;

            // Update sorted to the new head
            sorted = curr;
            sorted->prev = NULL;

        } 
        else {
          
            // Pointer to traverse the sorted part
            struct Node* current_sorted = sorted;

            // Find the correct position to insert
            while (current_sorted->next != NULL &&
                   current_sorted->next->data < curr->data) {
                current_sorted = current_sorted->next;
            }

            // Insert `curr` after `current_sorted`
            curr->next = current_sorted->next;

            // Set `prev` if `curr` is not inserted
            // at the end
            if (current_sorted->next != NULL)
                current_sorted->next->prev = curr;

            // Set `next` of `current_sorted` to `curr`
            current_sorted->next = curr;
            curr->prev = current_sorted;
        }

        curr = next;
    }

    return sorted;
}

void printList(struct Node* node) {
  
    struct Node* curr = node;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
}

struct Node* createNode(int new_data) {
    struct Node* new_node =
      (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    new_node->prev = NULL;
    return new_node;
}

int main() {

    // Create a hard-coded doubly linked list:
    // 5 <-> 3 <-> 4 <-> 1 <-> 2
    struct Node* head = createNode(5);
    head->next = createNode(3);
    head->next->prev = head;
    head->next->next = createNode(4);
    head->next->next->prev = head->next;
    head->next->next->next = createNode(1);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = createNode(2);
    head->next->next->next->next->prev
                        = head->next->next->next;

    head = insertionSort(head);

    printList(head);

    return 0;
}

Java

// Java program to sort a doubly linked list 
// using insertion sort
class Node {
    int data;
    Node next, prev;

    Node(int x) {
        data = x;
        next = null;
        prev = null;
    }
}

public class GfG {
    
    // Function to sort the linked list using
    // insertion sort
    static Node insertionSort(Node head) {
        if (head == null) return head;

        // Sorted part of the list
        Node sorted = null;

        // Current node to be inserted
        Node curr = head;

        // Traverse the list to sort each element
        while (curr != null) {
          
            // Store the next node to process
            Node next = curr.next;

            // Insert `curr` into the sorted part
            if (sorted == null ||
                          sorted.data >= curr.data) {
                curr.next = sorted;

                // If sorted is not empty, set its `prev`
                if (sorted != null) sorted.prev = curr;

                // Update sorted to the new head
                sorted = curr;
                sorted.prev = null;

            } 
            else {
              
                // Pointer to traverse the sorted part
                Node currentSorted = sorted;

                // Find the correct position to insert
                while (currentSorted.next != null &&
                       currentSorted.next.data < curr.data) {
                    currentSorted = currentSorted.next;
                }

                // Insert `curr` after `currentSorted`
                curr.next = currentSorted.next;

                // Set `prev` if `curr` is not inserted
                // at the end
                if (currentSorted.next != null)
                    currentSorted.next.prev = curr;

                // Set `next` of `currentSorted` to `curr`
                currentSorted.next = curr;
                curr.prev = currentSorted;
            }
            curr = next;
        }

        return sorted;
    }

    static void printList(Node node) {
        Node curr = node;
        while (curr != null) {
            System.out.print(" " + curr.data);
            curr = curr.next;
        }
    }

    public static void main(String[] args) {
      
        // Create a hard-coded doubly linked list:
        // 5 <-> 3 <-> 4 <-> 1 <-> 2
        Node head = new Node(5);
        head.next = new Node(3);
        head.next.prev = head;
        head.next.next = new Node(4);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(1);
        head.next.next.next.prev = head.next.next;
        head.next.next.next.next = new Node(2);
        head.next.next.next.next.prev 
                         = head.next.next.next;

        head = insertionSort(head);

        printList(head);
    }
}

Python

# Python program to sort a doubly linked list using
# insertion sort
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

# Function to sort the linked list using
# insertion sort
def insertion_sort(head):
    if not head:
        return head

    sorted_head = None
    curr = head

    # Traverse the list to sort each element
    while curr:
      
        # Store the next node to process
        next_node = curr.next

        # Insert `curr` into the sorted part
        if not sorted_head or sorted_head.data >= curr.data:
            curr.next = sorted_head

            # If sorted is not empty, set its `prev`
            if sorted_head:
                sorted_head.prev = curr

            # Update sorted to the new head
            sorted_head = curr
            sorted_head.prev = None
        else:
          
            # Pointer to traverse the sorted part
            current_sorted = sorted_head

            # Find the correct position to insert
            while (current_sorted.next and
                   current_sorted.next.data < curr.data):
                current_sorted = current_sorted.next

            # Insert `curr` after `current_sorted`
            curr.next = current_sorted.next

            # Set `prev` if `curr` is not inserted
            # at the end
            if current_sorted.next:
                current_sorted.next.prev = curr

            # Set `next` of `current_sorted` to `curr`
            current_sorted.next = curr
            curr.prev = current_sorted

        # Move to the next node to be sorted
        curr = next_node

    return sorted_head

def print_list(node):
    curr = node
    while curr:
        print(curr.data, end=" ")
        curr = curr.next

if __name__ == '__main__':
  
    # Create a hard-coded doubly linked list:
    # 5 <-> 3 <-> 4 <-> 1 <-> 2
    head = Node(5)
    head.next = Node(3)
    head.next.prev = head
    head.next.next = Node(4)
    head.next.next.prev = head.next
    head.next.next.next = Node(1)
    head.next.next.next.prev = head.next.next
    head.next.next.next.next = Node(2)
    head.next.next.next.next.prev = head.next.next.next

    head = insertion_sort(head)
    print_list(head)

// C# program to sort a singly linked list using 
// insertion sort 
using System;

public class Node {
    public int data;
    public Node next;

    public Node(int new_data) {
        data = new_data;
        next = null;
    }
}

class GfG {
  
    // Function to sort the linked list using
    // insertion sort
    static Node InsertionSort(Node head) {
        if (head == null) return head;

        Node sorted = null;
        Node curr = head;

        // Traverse the list to sort each element
        while (curr != null) {
          
            // Store the next node to process
            Node next = curr.next;

            // Insert `curr` into the sorted part
            if (sorted == null || sorted.data 
                                       >= curr.data) {
                curr.next = sorted;

                // Update sorted to the new head
                sorted = curr;
            } 
            else {
             
                // Pointer to traverse the sorted part
                Node currentSorted = sorted;

                // Find the correct position to insert
                while (currentSorted.next != null && 
                       currentSorted.next.data < curr.data) {
                    currentSorted = currentSorted.next;
                }

                // Insert `curr` after `currentSorted`
                curr.next = currentSorted.next;
                currentSorted.next = curr;
            }
            curr = next;
        }

        return sorted;
    }

    static void PrintList(Node node) {
        Node curr = node;
        while (curr != null) {
            Console.Write(" " + curr.data);
            curr = curr.next;
        }
    }

    static void Main(string[] args) {
      
        // Create a hard-coded linked list:
        // 5 -> 3 -> 4 -> 1 -> 2
        Node head = new Node(5);
        head.next = new Node(3);
        head.next.next = new Node(4);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(2);

        head = InsertionSort(head);
        PrintList(head);
    }
}

JavaScript

// JavaScript program to sort a doubly linked list 
// using insertion sort
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// Function to sort the doubly linked list
// using insertion sort
function insertionSort(head) {
    if (!head) return head;

    let sorted = null;
    let curr = head;

    // Traverse the list to sort each element
    while (curr !== null) {
    
        // Store the next node to process
        let next = curr.next;

        // Insert `curr` into the sorted part
        if (sorted === null || sorted.data >= curr.data) {
            curr.next = sorted;

            // Update `prev` if sorted is not empty
            if (sorted !== null) sorted.prev = curr;

            // Update sorted to the new head
            sorted = curr;
            sorted.prev = null;
        } 
        else {
        
            // Pointer to traverse the sorted part
            let currentSorted = sorted;

            // Find the correct position to insert
            while (currentSorted.next !== null && 
                   currentSorted.next.data < curr.data) {
                currentSorted = currentSorted.next;
            }

            // Insert `curr` after `currentSorted`
            curr.next = currentSorted.next;

            // Set `prev` if `curr` is not inserted at the end
            if (currentSorted.next !== null) 
                currentSorted.next.prev = curr;

            currentSorted.next = curr;
            curr.prev = currentSorted;
        }

        // Move to the next node to be sorted
        curr = next;
    }

    return sorted;
}

function printList(node) {
    let curr = node;
    while (curr !== null) {
        process.stdout.write(" " + curr.data);
        curr = curr.next;
    }
}

// Create a hard-coded doubly 
// linked list: 5 <-> 3 <-> 4 <-> 1 <-> 2
let head = new Node(5);
head.next = new Node(3);
head.next.prev = head;
head.next.next = new Node(4);
head.next.next.prev = head.next;
head.next.next.next = new Node(1);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(2);
head.next.next.next.next.prev = head.next.next.next;

head = insertionSort(head);

printList(head);

Output

 1 2 3 4 5

Time Complexity: O(n^2), as we are using nested loops for sorting, where n is the number of nodes in the linked list.
Auxiliary Space: O(1)

Related article: