Codestin Search App

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

Understanding the Visualization

Split the Deck

Find the exact middle and split into two equal (or nearly equal) halves

Flip Second Half

Reverse the order of cards in the second half

Interweave

Alternate taking one card from each half to create the final sequence

Key Takeaway

🎯 Key Insight: By reversing the second half first, we can easily alternate between the start and end elements during the merge phase, achieving perfect interleaving with O(1) space complexity.

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

Approach	Time	Space	Notes
✓ Brute Force (Array Storage)	O(n)	O(n)	Store all nodes in an array, then reconnect them in the desired order
Three-Step Optimal (Find Middle + Reverse + Merge)	O(n)	O(1)	Find middle, reverse second half, merge alternately - truly in-place solution

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;
    for (int i = 0; i < count - 1; i++) {
        if (i % 2 == 0) {
            nodes[left]->next = right > left ? nodes[right] : NULL;
            left++;
        } else {
            nodes[right]->next = left <= right ? nodes[left] : NULL;
            right--;
        }
    }
    
    // Set last node's next to NULL
    int lastIdx = left < right + 1 ? left : right + 1;
    nodes[lastIdx]->next = NULL;
    
    free(nodes);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    int values[100];
    int count = 0;
    char* token = strtok(input, " \n");
    
    while (token != NULL && count < 100) {
        values[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    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

⚡ Linearithmic 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