Sort List - Practice Coding Problems

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
✓ 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)	O(n log n)	O(n)	Convert linked list to array, sort array, rebuild linked list

Merge Sort (Divide and Conquer) — Algorithm Steps

Base case: if list has 0 or 1 node, it's already sorted
Find the middle using slow/fast pointers (two-pointer technique)
Split the list into two halves at the middle
Recursively sort both halves
Merge the two sorted halves back together
Return the head of the merged sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Middle

Use slow/fast pointers to find middle of list

Split & Recurse

Split at middle and recursively sort both halves

Merge

Merge the two sorted halves back together

Code -

solution.c — C

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

#include <stdlib.h>

struct ListNode* getMid(struct ListNode* head) {
    struct ListNode* midPrev = NULL;
    while (head && head->next) {
        midPrev = (midPrev == NULL) ? head : midPrev->next;
        head = head->next->next;
    }
    struct ListNode* mid = midPrev->next;
    midPrev->next = NULL; // Split the list
    return mid;
}

struct ListNode* merge(struct ListNode* list1, struct ListNode* list2) {
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    struct ListNode* tail = dummy;
    
    while (list1 && list2) {
        if (list1->val < list2->val) {
            tail->next = list1;
            list1 = list1->next;
        } else {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
    }
    tail->next = list1 ? list1 : list2;
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

struct ListNode* sortList(struct ListNode* head) {
    if (!head || !head->next) return head;
    
    // Get middle and split the list
    struct ListNode* mid = getMid(head);
    
    // Recursively sort both halves
    struct ListNode* left = sortList(head);
    struct ListNode* right = sortList(mid);
    
    // Merge sorted halves
    return merge(left, right);
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each level of recursion takes O(n) time to merge, and there are O(log n) levels

⚡ Linearithmic

Space Complexity

O(log n)

Only recursion stack space is used, no additional data structures

⚡ 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

Merge Sort (Divide and Conquer) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler