Insertion Sort List - Practice Coding Problems

Insertion Sort List - Problem

Sort a Singly Linked List Using Insertion Sort

Given the head of a singly linked list, your task is to sort the list using the insertion sort algorithm and return the head of the sorted list.

How insertion sort works:
🔄 Iterative process: Takes one element at a time from the unsorted portion
🎯 Find position: Locates the correct position in the already sorted portion
🔗 Insert in place: Places the element at its correct position
♻️ Repeat: Continues until all elements are processed

The challenge here is implementing this classic sorting algorithm on a linked list instead of an array, which requires careful pointer manipulation to maintain the list structure while sorting.

Input & Output

example_1.py — Standard Case

$ Input: head = [4,2,1,3]

› Output: [1,2,3,4]

💡 Note: The linked list 4→2→1→3 is sorted using insertion sort. Each element is taken from the unsorted portion and inserted into its correct position in the sorted portion, resulting in 1→2→3→4.

example_2.py — Already Sorted

$ Input: head = [1,2,3,4]

› Output: [1,2,3,4]

💡 Note: The linked list is already sorted, so insertion sort maintains the same order. This is the best case scenario for insertion sort with O(n) time complexity.

example_3.py — Single Node

$ Input: head = [42]

› Output: [42]

💡 Note: A single node is already sorted by definition. The algorithm handles this edge case by returning the same node.

Visualization

Tap to expand

Understanding the Visualization

Pick Next Card

Take the next unsorted card from the pile

Find Position

Compare with sorted cards to find where it belongs

Slide Into Place

Insert the card at its correct position

Repeat

Continue until all cards are sorted

Key Takeaway

🎯 Key Insight: Insertion sort works by maintaining two portions - sorted (left) and unsorted (right). For each element, we find its correct position in the sorted portion and insert it there, gradually growing the sorted portion until the entire list is sorted.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we may need to traverse up to n nodes to find insertion position

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for pointers

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 5000]
-5000 ≤ Node.val ≤ 5000
The input is a singly linked list (no backward pointers)
You must sort the list in-place using insertion sort algorithm

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses insertion sort directly on the linked list structure with O(1) space complexity. We maintain a dummy head and for each node, find its correct position in the already sorted portion by traversing from the beginning. The key insight is that we can reuse existing nodes and only need to manipulate pointers, avoiding the extra space required by array-based approaches. While the time complexity is O(n²) in worst case, this solution is true to the problem requirements and performs well on nearly sorted lists.

Common Approaches

Approach	Time	Space	Notes
✓ Insertion Sort with Optimized Position Finding	O(n²)	O(1)	True insertion sort on linked list with optimized insertion position detection
Convert to Array and Sort	O(n log n)	O(n)	Convert linked list to array, sort array, rebuild linked list

Insertion Sort with Optimized Position Finding — Algorithm Steps

Initialize a dummy head for easier manipulation
Keep track of the sorted portion (initially just the first node)
For each remaining node, find its correct position in the sorted portion
Remove the node from its current position
Insert the node at the correct position in the sorted portion
Continue until all nodes are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create dummy head and prepare for insertion

Find Position

Locate correct position in sorted portion

Insert Node

Remove from current position and insert at correct location

Repeat

Continue with next unsorted node

Code -

solution.c — C

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* insertionSortList(struct ListNode* head) {
    if (!head || !head->next) return head;
    
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = INT_MIN;
    dummy->next = NULL;
    
    while (head) {
        // Remove the node from original list
        struct ListNode* nextNode = head->next;
        
        // Find insertion position in sorted portion
        struct ListNode* prev = dummy;
        while (prev->next && prev->next->val < head->val) {
            prev = prev->next;
        }
        
        // Insert the node
        head->next = prev->next;
        prev->next = head;
        
        // Move to next node in original list
        head = nextNode;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we may need to traverse up to n nodes to find insertion position

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for pointers

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 5000]
-5000 ≤ Node.val ≤ 5000
The input is a singly linked list (no backward pointers)
You must sort the list in-place using insertion sort algorithm

52.0K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Insertion Sort with Optimized Position Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler