Sort List

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

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

✓ Brute Force (Convert to Array)

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

The simplest approach is to traverse the linked list and store all values in an array, sort the array using built-in sorting, then create a new linked list with the sorted values. This ignores the linked list structure entirely.

Merge Sort (Divide and Conquer)

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

The optimal approach uses merge sort, which is perfect for linked lists. We use the two-pointer technique to find the middle of the list (slow/fast pointers), split the list into two halves, recursively sort each half, and then merge the two sorted halves back together.

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

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

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

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;
}

struct ListNode* createLinkedList(int* values, int count) {
    if (count == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; 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;
    }
    return head;
}

void linkedListToArray(struct ListNode* head, int* result, int* count) {
    *count = 0;
    struct ListNode* current = head;
    while (current) {
        result[*count] = current->val;
        (*count)++;
        current = current->next;
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    if (strcmp(input, "[]") == 0 || strlen(input) == 0) {
        printf("[]\n");
        return 0;
    }
    
    int values[50000];
    int count = 0;
    
    char* token = strtok(input, ",");
    while (token != NULL) {
        values[count++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    struct ListNode* head = createLinkedList(values, count);
    struct ListNode* sortedHead = sortList(head);
    
    int result[50000];
    int resultCount;
    linkedListToArray(sortedHead, result, &resultCount);
    
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("\n");
    
    return 0;
}

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