Interleave Two Linked Lists

Interleave Two Linked Lists - Problem

You are given the heads of two linked lists list1 and list2.

Interleave the nodes by alternating between the two lists: take the first node from list1, then the first node from list2, then the second node from list1, then the second node from list2, and so on.

If one list is longer than the other, append the remaining nodes at the end.

Return the head of the interleaved linked list.

Input & Output

Example 1 — Equal Length

$ Input: list1 = [1,3,5], list2 = [2,4,6]

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

💡 Note: Alternate: 1(list1), 2(list2), 3(list1), 4(list2), 5(list1), 6(list2)

Example 2 — Unequal Length

$ Input: list1 = [1,2], list2 = [10,20,30,40]

› Output: [1,10,2,20,30,40]

💡 Note: Alternate: 1(list1), 10(list2), 2(list1), 20(list2), then remaining from list2: 30, 40

Example 3 — One Empty

$ Input: list1 = [], list2 = [5,10]

› Output: [5,10]

💡 Note: list1 is empty, so return list2 as-is

Constraints

The number of nodes in both lists is in the range [0, 50].
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 32 G Google 22

The key insight is to rewire pointers directly by saving next references before modifying them. Alternate between list1 and list2, linking each node to the other list's current node. Time: O(m+n), Space: O(1).

Common Approaches

✓ Collect and Rebuild

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

Collect all values from both lists into separate arrays. Then build a new linked list by alternating values from each array. Append remaining values from the longer array.

In-Place Pointer Rewiring

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

Use two pointers to traverse both lists simultaneously. For each pair of nodes, save the next pointers, then rewire: current node from list1 points to current node from list2, which points to the next node from list1. Continue until one list is exhausted.

Collect and Rebuild — Algorithm Steps

Step 1: Traverse both lists and collect values into two arrays
Step 2: Create new list by alternating values from each array
Step 3: Append remaining values from the longer array
Step 4: Return head of new list

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect

arr1 = [1,3,5], arr2 = [2,4,6]

Interleave

Take arr1[0], arr2[0], arr1[1], arr2[1], ...

Result

New list: 1 → 2 → 3 → 4 → 5 → 6

Code -

solution.c — C

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

int parseArrays(int arr1[], int* s1, int arr2[], int* s2) {
    int ch, num, neg, arrIdx, idx;
    arrIdx = 0;
    idx = 0;
    *s1 = 0;
    *s2 = 0;
    
    while ((ch = getchar()) != EOF) {
        if (ch == '[') {
            idx = 0;
            while ((ch = getchar()) != EOF && ch != ']') {
                if (ch == '-' || (ch >= '0' && ch <= '9')) {
                    neg = 0;
                    num = 0;
                    if (ch == '-') { neg = 1; ch = getchar(); }
                    while (ch >= '0' && ch <= '9') {
                        num = num * 10 + (ch - '0');
                        ch = getchar();
                    }
                    if (neg) num = -num;
                    if (arrIdx == 0) arr1[idx++] = num;
                    else arr2[idx++] = num;
                    if (ch == ']') break;
                }
            }
            if (arrIdx == 0) *s1 = idx;
            else *s2 = idx;
            arrIdx++;
        }
    }
    return 0;
}

int main() {
    int arr1[200], arr2[200], s1, s2;
    int result[400], ri;
    int a, b, i;
    
    parseArrays(arr1, &s1, arr2, &s2);
    
    ri = 0;
    a = 0;
    b = 0;
    while (a < s1 && b < s2) {
        result[ri++] = arr1[a++];
        result[ri++] = arr2[b++];
    }
    while (a < s1) result[ri++] = arr1[a++];
    while (b < s2) result[ri++] = arr2[b++];
    
    printf("[");
    for (i = 0; i < ri; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

Traverse both lists once to collect, once to build

✓ Linear Growth

Space Complexity

O(m + n)

Arrays to store all values plus new linked list nodes

⚡ Linearithmic Space

0 Views

High Frequency

~12 min Avg. Time

0 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

Collect and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler