Partition List - Practice Coding Problems

Partition List - Problem

Partition List is a classic linked list manipulation problem that tests your ability to reorganize nodes while preserving order.

You are given the head of a singly linked list and a pivot value x. Your task is to partition the list such that:

All nodes with values less than x come before nodes with values greater than or equal to x
The original relative order of nodes in each partition must be preserved

Think of it like organizing a line of people by height while keeping friends together in their original order within each height group!

Example: Given list 1→4→3→2→5→2 and x = 3, the result should be 1→2→2→4→3→5

Input & Output

example_1.py — Basic Partition

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

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

💡 Note: Nodes with values less than 3 (1,2,2) come first in their original order, followed by nodes with values ≥ 3 (4,3,5) in their original order.

example_2.py — All Elements Same Side

$ Input: head = [2,1], x = 2

› Output: [1,2]

💡 Note: Node with value 1 < 2 comes first, followed by node with value 2 ≥ 2.

example_3.py — Single Node

$ Input: head = [1], x = 2

› Output: [1]

💡 Note: Single node case: since 1 < 2, the node stays in place as the only element in the 'smaller' partition.

Constraints

The number of nodes in the list is in the range [0, 200]
-100 ≤ Node.val ≤ 100
-200 ≤ x ≤ 200

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Create two dummy heads - one for shorter students (< height x) and one for taller students (≥ height x)

Sorting Phase

Go through each student and direct them to the appropriate line while maintaining their position relative to friends

Connection Phase

Connect the end of the shorter students line to the beginning of the taller students line

Final Result

Remove dummy heads and return the combined line with proper partitioning

Key Takeaway

🎯 Key Insight: Using dummy heads transforms complex edge case handling into simple chain building, making the code cleaner and more reliable.

Asked in

A Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 18

The optimal solution uses two dummy heads to build separate chains for nodes smaller than x and nodes greater than or equal to x. This approach achieves O(n) time and O(1) space complexity with a single pass through the list.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Array Conversion)	O(n)	O(n)	Convert to array, partition, then rebuild linked list
Two Pointers (Optimal)	O(n)	O(1)	Use two dummy heads to build separate chains, then merge

Brute Force (Array Conversion) — Algorithm Steps

Traverse the linked list and store all values in an array
Partition the array by moving smaller elements to the front
Create a new linked list from the partitioned array
Return the head of the new list

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Convert linked list [1→4→3→2→5→2] to array [1,4,3,2,5,2]

Partition Array

Separate into smaller=[1,2,2] and larger=[4,3,5] arrays

Combine Arrays

Merge arrays to get [1,2,2,4,3,5]

Rebuild List

Create new linked list from partitioned array

Code -

solution.c — C

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

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

struct ListNode* partition(struct ListNode* head, int x) {
    if (!head) return head;
    
    // Count nodes
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    // Convert to array
    int* values = (int*)malloc(count * sizeof(int));
    current = head;
    for (int i = 0; i < count; i++) {
        values[i] = current->val;
        current = current->next;
    }
    
    // Partition array in-place
    int* partitioned = (int*)malloc(count * sizeof(int));
    int smallerIdx = 0;
    
    // First pass: add smaller elements
    for (int i = 0; i < count; i++) {
        if (values[i] < x) {
            partitioned[smallerIdx++] = values[i];
        }
    }
    
    // Second pass: add larger elements
    for (int i = 0; i < count; i++) {
        if (values[i] >= x) {
            partitioned[smallerIdx++] = values[i];
        }
    }
    
    // Rebuild linked list
    struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    newHead->val = partitioned[0];
    newHead->next = NULL;
    
    current = newHead;
    for (int i = 1; i < count; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = partitioned[i];
        current->next = NULL;
    }
    
    free(values);
    free(partitioned);
    return newHead;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to extract values, O(n) to partition array, O(n) to rebuild list

✓ Linear Growth

Space Complexity

O(n)

Additional array to store all node values

⚡ Linearithmic Space

73.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Array Conversion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler