Partition List

Partition List - Problem

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

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

Input & Output

Example 1 — 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 before nodes greater than or equal to 3 (4, 3, 5). Original relative order is preserved within each partition.

Example 2 — Single Element

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

› Output: [2]

💡 Note: Single node with value 2 is greater than x=1, so it remains in its position.

Example 3 — All Elements Same Side

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

› Output: [1,1,1]

💡 Note: All nodes have values less than x=5, 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 30 🍎 Apple 25 G Google 20

The key insight is to create two separate lists during traversal - one for nodes less than x and another for nodes greater than or equal to x. The optimal approach uses the Two Pointers technique with dummy heads to build these lists, then connects them together. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Multiple Pass Rearrangement

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

Traverse the linked list multiple times, each time finding nodes less than x and moving them to the beginning while maintaining their relative order. This requires multiple passes through the list.

Two Pointers - Separate Lists

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

Traverse the original list once, creating two separate linked lists: one for nodes less than x and another for nodes greater than or equal to x. Finally, connect the two lists together.

Brute Force - Multiple Pass Rearrangement — Algorithm Steps

Scan list to find first node >= x
Find next node < x and move it before the >= x section
Repeat until no more nodes < x are found after >= x nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial List

Original linked list with mixed values

Pass 1

Find and move first node < x that comes after >= x

Pass 2

Continue until all nodes < x are moved to front

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) {
    if (!head) return head;
    
    // Count nodes
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        count++;
        curr = curr->next;
    }
    
    // Collect values
    int* values = (int*)malloc(count * sizeof(int));
    curr = head;
    for (int i = 0; i < count; i++) {
        values[i] = curr->val;
        curr = curr->next;
    }
    
    // Separate into before and after
    int* before = (int*)malloc(count * sizeof(int));
    int* after = (int*)malloc(count * sizeof(int));
    int beforeCount = 0, afterCount = 0;
    
    for (int i = 0; i < count; i++) {
        if (values[i] < x) {
            before[beforeCount++] = values[i];
        } else {
            after[afterCount++] = values[i];
        }
    }
    
    // Reconstruct list
    if (beforeCount + afterCount == 0) {
        free(values);
        free(before);
        free(after);
        return NULL;
    }
    
    struct ListNode* result = (struct ListNode*)malloc(sizeof(struct ListNode));
    result->val = (beforeCount > 0) ? before[0] : after[0];
    result->next = NULL;
    
    curr = result;
    
    // Add remaining before nodes
    for (int i = 1; i < beforeCount; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = before[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    
    // Add after nodes
    int startIdx = (beforeCount > 0) ? 0 : 1;
    for (int i = startIdx; i < afterCount; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = after[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    
    free(values);
    free(before);
    free(after);
    
    return result;
}

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

void printList(struct ListNode* head) {
    printf("[");
    int first = 1;
    while (head) {
        if (!first) printf(",");
        printf("%d", head->val);
        first = 0;
        head = head->next;
    }
    printf("]\n");
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    char* ptr = line + 1; // Skip [
    char* token;
    while ((token = strtok(ptr, ",]")) != NULL) {
        int val = atoi(token);
        struct ListNode* node = createNode(val);
        if (!head) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
        ptr = NULL;
    }
    
    int x;
    scanf("%d", &x);
    
    struct ListNode* result = solution(head, x);
    printList(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, need n passes through the list, each pass taking O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only uses a few pointer variables, no extra data structures

✓ Linear Space

380.0K Views

Medium Frequency

~15 min Avg. Time

4.3K 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 - Multiple Pass Rearrangement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler