Linked List Zipper - Problem

Given a singly linked list L0 → L1 → L2 → ... → Ln-1 → Ln, reorder it to: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → ...

The reordering should alternate between nodes from the beginning and nodes from the end of the list, creating a "zipper" pattern.

Important: You must do this in-place without changing the values in the list's nodes.

Examples:

[1,2,3,4] becomes [1,4,2,3]
[1,2,3,4,5] becomes [1,5,2,4,3]

Input & Output

Example 1 — Basic Odd Length

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

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

💡 Note: Zipper pattern: take from start (1), then end (5), then start (2), then end (4), finally middle (3)

Example 2 — Even Length

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

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

💡 Note: Alternate between start and end: 1 (start), 4 (end), 2 (start), 3 (end)

Example 3 — Single Node

$ Input: head = [1]

› Output: [1]

💡 Note: Single node remains unchanged

Constraints

1 ≤ Number of nodes ≤ 5 × 10⁴
1 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

F Facebook 35 a Amazon 28 M Microsoft 22 G Google 18

The key insight is to split the linked list at the middle, reverse the second half, then merge the two halves alternately. Best approach uses the three-step technique: find middle with slow/fast pointers, reverse second half in-place, then interleave nodes. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Array Conversion

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

Store all node values in an array, determine the zipper order, then create a new linked list with values in the correct positions.

Optimal - Three-Step In-Place

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

Use the classic three-step approach: find the middle node, reverse the second half of the list, then merge the two halves by alternating connections.

Brute Force - Array Conversion — Algorithm Steps

Traverse linked list and store all values in array
Calculate zipper pattern indices
Create new linked list with rearranged values

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Read all values from linked list into array

Zipper Pattern

Alternate between start and end indices

Rebuild List

Create new linked list with rearranged values

Code -

solution.c — C

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

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

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

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

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

struct ListNode* solution(struct ListNode* head) {
    if (!head || !head->next) return head;
    
    // Convert to array
    int values[10000];
    int n = 0;
    struct ListNode* current = head;
    while (current) {
        values[n++] = current->val;
        current = current->next;
    }
    
    int result[10000];
    
    // Create zipper pattern
    int left = 0, right = n - 1;
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            result[i] = values[left];
            left++;
        } else {
            result[i] = values[right];
            right--;
        }
    }
    
    // Create new linked list
    return arrayToList(result, n);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    
    // Parse array
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            arr[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    int resultArray[1000];
    int resultSize = listToArray(result, resultArray);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", resultArray[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to read values, single pass to create new list

✓ Linear Growth

Space Complexity

O(n)

Array to store all node values

⚡ Linearithmic Space

156.2K Views

Medium Frequency

~25 min Avg. Time

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

Linked List Zipper - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Array Conversion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler