Reorder List

Reorder List - Problem

Reorder List is a fascinating linked-list manipulation problem that challenges you to interweave nodes from opposite ends of the list.

Given the head of a singly linked-list, you need to transform it from its original form:
L₀ → L₁ → L₂ → ... → Lₙ₋₁ → Lₙ

Into this interleaved pattern:
L₀ → Lₙ → L₁ → Lₙ₋₁ → L₂ → Lₙ₋₂ → ...

Important constraints:

You cannot modify the values inside the nodes
You can only rearrange the node connections
The reordering must be done in-place

Example: If your list is [1,2,3,4,5], the result should be [1,5,2,4,3] - taking alternately from the start and end!

Input & Output

example_1.py — Basic Reordering

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

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

💡 Note: We alternate between the start and end: take 1 (start), then 4 (end), then 2 (next start), then 3 (next end). The pattern is L₀ → Lₙ → L₁ → Lₙ₋₁.

example_2.py — Odd Length List

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

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

💡 Note: With 5 nodes, we get: 1 (first), 5 (last), 2 (second), 4 (second-last), 3 (middle). The middle element naturally ends up at the end of our reordered sequence.

example_3.py — Edge Case - Two Nodes

$ Input: head = [1,2]

› Output: [1,2]

💡 Note: With only two nodes, taking first→last gives us the same order: 1→2. This is a base case where no actual reordering is needed.

Constraints

The number of nodes in the list is in the range [1, 5 × 10⁴]
1 ≤ Node.val ≤ 1000
You may not modify the values in the list's nodes. Only nodes themselves may be changed.

Visualization

Tap to expand

Asked in

a Amazon 45 f Meta 38 ⊞ Microsoft 32 G Google 28

The optimal solution uses a three-step approach: find the middle using fast/slow pointers, reverse the second half, then merge alternately. This achieves O(1) space and O(n) time complexity, making it a truly in-place solution that's both elegant and efficient.

Common Approaches

✓ Brute Force (Array Storage)

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

The most straightforward approach is to traverse the entire linked list and store all nodes in an array. Once we have random access to all nodes, we can easily reconnect them in the alternating pattern required by the problem. This trades space for simplicity.

Three-Step Optimal (Find Middle + Reverse + Merge)

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

The optimal approach breaks the problem into three manageable steps: 1) Find the middle of the list using fast/slow pointers, 2) Reverse the second half of the list, and 3) Merge the two halves alternately. This achieves O(1) space complexity while maintaining O(n) time complexity.

Brute Force (Array Storage) — Algorithm Steps

Traverse the linked list and store all nodes in an array
Calculate the reordering pattern: alternate between start and end indices
Reconnect the nodes by setting next pointers according to the pattern
Set the last node's next pointer to null

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Nodes

Traverse linked list and store all nodes in array

Reorder Pattern

Use two pointers (left=0, right=n-1) to alternate connections

Reconnect

Connect nodes: arr[0]→arr[n-1]→arr[1]→arr[n-2]...

Code -

solution.c — C

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

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

void reorderList(struct ListNode* head) {
    if (!head || !head->next) return;
    
    // Count nodes first
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        count++;
        curr = curr->next;
    }
    
    // Store all nodes in array
    struct ListNode** nodes = (struct ListNode**)malloc(count * sizeof(struct ListNode*));
    curr = head;
    for (int i = 0; i < count; i++) {
        nodes[i] = curr;
        curr = curr->next;
    }
    
    // Reconnect nodes in alternating pattern
    int left = 0, right = count - 1;
    while (left < right) {
        nodes[left]->next = nodes[right];
        left++;
        if (left < right) {
            nodes[right]->next = nodes[left];
            right--;
        }
    }
    
    // Set last node's next to NULL
    nodes[left]->next = NULL;
    
    free(nodes);
}

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;
    }
    
    // Remove brackets if present
    char* start = input;
    if (start[0] == '[') start++;
    int len = strlen(start);
    if (len > 0 && start[len-1] == ']') start[len-1] = '\0';
    
    if (strlen(start) == 0) {
        printf("\n");
        return 0;
    }
    
    // Parse comma-separated values
    int values[10000];
    int count = 0;
    char* token = strtok(start, ",");
    
    while (token != NULL && count < 10000) {
        values[count++] = (int)strtol(token, NULL, 10);
        token = strtok(NULL, ",");
    }
    
    if (count == 0) {
        printf("\n");
        return 0;
    }
    
    // Create linked list
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    
    struct ListNode* curr = head;
    for (int i = 1; i < count; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = values[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    
    reorderList(head);
    
    // Print result
    curr = head;
    int first = 1;
    while (curr) {
        if (!first) printf(",");
        printf("%d", curr->val);
        first = 0;
        curr = curr->next;
    }
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to collect nodes plus O(n) to reconnect them

✓ Linear Growth

Space Complexity

O(n)

Array to store all n nodes

✓ Linear Space

42.0K Views

High Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Array Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler