Codestin Search App

Sort List - Problem

You are given the head of a singly linked list containing integers. Your task is to sort the entire linked list in ascending order and return the head of the sorted list.

The challenge here is that unlike arrays, linked lists don't provide random access to elements. You can only traverse them sequentially, which makes traditional sorting algorithms like quicksort less efficient. The optimal solution should achieve O(n log n) time complexity while using only O(log n) space for recursion.

Example: Given a linked list 4 → 2 → 1 → 3, you should return 1 → 2 → 3 → 4.

Input & Output

example_1.py — Basic Sorting

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

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

💡 Note: The linked list contains nodes with values 4->2->1->3. After sorting in ascending order, we get 1->2->3->4.

example_2.py — Already Sorted

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

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

💡 Note: The linked list is already sorted in ascending order, so no changes are needed.

example_3.py — Empty List

$ Input: head = []

› Output: []

💡 Note: An empty linked list remains empty after sorting.

Constraints

The number of nodes in the list is in the range [0, 5 × 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Follow up: Can you sort the linked list in O(n log n) time and O(1) memory (i.e. constant space)?

Visualization

Tap to expand

Understanding the Visualization

Divide

Split the linked list into two halves using slow/fast pointers

Conquer

Recursively sort each half until we have single nodes

Merge

Merge two sorted halves back together in sorted order

Key Takeaway

🎯 Key Insight: Merge sort is perfect for linked lists because merging is naturally efficient with pointer manipulation, and we don't need the random access that other O(n log n) algorithms require.

Asked in

a Amazon 45 ⊞ Microsoft 38 f Meta 32 G Google 28

The optimal solution uses merge sort with the two-pointer technique. We use slow/fast pointers to find the middle, recursively sort both halves, and merge them back together. This achieves O(n log n) time complexity and O(log n) space complexity, making it the most efficient approach for sorting linked lists.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Convert to Array)	O(n log n)	O(n)	Convert linked list to array, sort array, rebuild linked list
Merge Sort (Divide and Conquer)	O(n log n)	O(log n)	Split list in half using slow/fast pointers, recursively sort, then merge

Brute Force (Convert to Array) — Algorithm Steps

Traverse the linked list and store all values in an array
Sort the array using any sorting algorithm (built-in sort)
Create a new linked list with sorted values
Return the head of the new sorted linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Traverse linked list and store values in array

Sort Array

Use built-in sorting on the array

Rebuild List

Create new linked list from sorted array

Code -

solution.c — C

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

#include <stdlib.h>

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

struct ListNode* sortList(struct ListNode* head) {
    if (!head) return NULL;
    
    // Step 1: Count nodes and convert to array
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    int* values = (int*)malloc(count * sizeof(int));
    current = head;
    for (int i = 0; i < count; i++) {
        values[i] = current->val;
        current = current->next;
    }
    
    // Step 2: Sort the array
    qsort(values, count, sizeof(int), compare);
    
    // Step 3: Create new sorted linked list
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    current = dummy;
    
    for (int i = 0; i < count; i++) {
        struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
        newNode->val = values[i];
        newNode->next = NULL;
        current->next = newNode;
        current = current->next;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    free(values);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to traverse the list + O(n log n) to sort array + O(n) to rebuild list

⚡ Linearithmic

Space Complexity

O(n)

O(n) extra space needed for the array to store all values

⚡ Linearithmic Space

89.0K Views

High Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Convert to Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler