Linked List Sorter - Problem

Given the head of a singly linked list, sort it using merge sort algorithm and return the sorted list's head.

You must implement the complete merge sort algorithm for linked lists, which involves:

Finding the middle of the linked list
Splitting the list into two halves
Merging two sorted linked lists

The algorithm should work in-place and maintain O(n log n) time complexity.

Input & Output

Example 1 — Basic Unsorted List

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

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

💡 Note: The merge sort algorithm splits the list at middle (between 2 and 1), recursively sorts both halves [4,2]→[2,4] and [1,3]→[1,3], then merges them back: [1,2,3,4]

Example 2 — Already Sorted

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

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

💡 Note: Even though the list is already sorted, merge sort still works by splitting and merging, but no reordering occurs during the merge steps

Example 3 — Single Element

$ Input: head = [42]

› Output: [42]

💡 Note: Base case: a single node is already sorted, so it returns immediately without any splitting or merging

Constraints

The number of nodes in the list is in the range [0, 5 × 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

A Amazon 45 M Microsoft 38 G Google 32 A Apple 25

The key insight is to use the divide-and-conquer approach of merge sort, where we find the middle using slow-fast pointers, recursively sort both halves, and merge them back together. Best approach uses merge sort with slow-fast pointers. Time: O(n log n), Space: O(log n)

Common Approaches

✓ Convert to Array and Sort

⏱️ Time: O(n log n) Space: O(n)

Extract all values from the linked list into an array, use built-in array sorting, then create a new sorted linked list from the array values.

Merge Sort with Slow-Fast Pointers

⏱️ Time: O(n log n) Space: O(log n)

Implement classic merge sort by recursively splitting the linked list at the middle (found using slow-fast pointers), sorting both halves, and merging them back together in sorted order.

Convert to Array and Sort — Algorithm Steps

Step 1: Traverse linked list and collect all values into an array
Step 2: Sort the array using built-in sort function
Step 3: Create new linked list nodes from sorted array values
Step 4: Connect the nodes to form the final sorted linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Traverse linked list and collect values into array

Sort Array

Use built-in sorting on the extracted array

Rebuild List

Create new linked list from sorted array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

struct ListNode* solution(struct ListNode* head) {
    if (!head) return NULL;
    
    // Convert to array
    int values[10000];
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        values[count++] = current->val;
        current = current->next;
    }
    
    // Sort array
    qsort(values, count, sizeof(int), compare);
    
    // Rebuild linked list
    if (count == 0) return NULL;
    
    struct ListNode* newHead = createNode(values[0]);
    current = newHead;
    for (int i = 1; i < count; i++) {
        current->next = createNode(values[i]);
        current = current->next;
    }
    
    return newHead;
}

int main() {
    // Simple parsing for demo
    printf("[1,2,3,4]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Built-in array sort is O(n log n), plus O(n) for list traversal and reconstruction

⚡ Linearithmic

Space Complexity

O(n)

Array stores all n values, plus recursion stack for sorting

⚡ Linearithmic Space

78.0K Views

High Frequency

~25 min Avg. Time

2.2K 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

Linked List Sorter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Convert to Array and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler