Linked List Partitioner - Problem

Given a linked list and a value x, partition it such that all nodes with values less than x come before all nodes with values greater than or equal to x.

Important: You should preserve the original relative order of the nodes in each of the two partitions.

Return the head of the modified linked list.

Input & Output

Example 1 — Basic Partition

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

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

💡 Note: Values less than 3 (1,2,2) come first, followed by values >= 3 (4,3,5). Original relative order is preserved within each group.

Example 2 — All Values Greater

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

› Output: [1,2]

💡 Note: Only value 1 is less than 2, so it comes first, followed by value 2.

Example 3 — Single Node

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

› Output: [1]

💡 Note: Single node case: 1 < 2, so the list remains unchanged.

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

Asked in

a Amazon 45 M Microsoft 32 🍎 Apple 28 G Google 25

The key insight is to use two dummy head nodes to build separate chains for values less than x and values greater than or equal to x. The optimal approach uses two dummy heads, traverses the list once, and connects the chains at the end. Time: O(n), Space: O(1).

Common Approaches

✓ Two Dummy Heads

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

Create two dummy head nodes - one for values less than x, another for values >= x. Traverse original list once, adding each node to appropriate chain. Finally connect the two chains.

Two-Pass Collection

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

First pass collects all node values into an array. Then separate values into 'less than x' and 'greater/equal to x' arrays. Finally, create a new linked list from the combined arrays.

Two Dummy Heads — Algorithm Steps

Create two dummy heads: beforeHead and afterHead
Traverse original list, directing each node to appropriate chain
Connect tail of 'before' chain to head of 'after' chain
Return the head of combined result

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Dummy Heads

Create before and after dummy nodes

Route Each Node

Direct nodes to appropriate chain based on value vs x

Connect Chains

Link tail of before chain to head of after chain

Code -

solution.c — C

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

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

struct ListNode* solution(struct ListNode* head, int x) {
    // Create two dummy heads
    struct ListNode beforeHead = {0, NULL};
    struct ListNode afterHead = {0, NULL};
    
    // Pointers to build chains
    struct ListNode* before = &beforeHead;
    struct ListNode* after = &afterHead;
    
    // Traverse original list
    struct ListNode* current = head;
    while (current) {
        if (current->val < x) {
            before->next = current;
            before = before->next;
        } else {
            after->next = current;
            after = after->next;
        }
        current = current->next;
    }
    
    // Connect the two chains
    after->next = NULL;  // End the after chain
    before->next = afterHead.next;  // Connect before chain to after chain
    
    return beforeHead.next;
}

int listToArray(struct ListNode* head, int* arr) {
    int count = 0;
    while (head) {
        arr[count++] = head->val;
        head = head->next;
    }
    return count;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = arr[i];
        current->next->next = NULL;
        current = current->next;
    }
    return head;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int x;
    scanf("%d", &x);
    
    int headArr[1000];
    int headSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            headArr[headSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* head = arrayToList(headArr, headSize);
    struct ListNode* result = solution(head, x);
    
    int resultArr[1000];
    int resultSize = listToArray(result, resultArr);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", resultArr[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal through all n nodes in the linked list

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant number of extra pointers (dummy heads and current pointers)

⚡ Linearithmic Space

78.5K Views

Medium Frequency

~25 min Avg. Time

1.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

Linked List Partitioner - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Dummy Heads — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler