Merge Nodes in Between Zeros

Merge Nodes in Between Zeros - Problem

You are given the head of a linked list, which contains a series of integers separated by 0's. The beginning and end of the linked list will have Node.val == 0.

For every two consecutive 0's, merge all the nodes lying in between them into a single node whose value is the sum of all the merged nodes. The modified list should not contain any 0's.

Return the head of the modified linked list.

Input & Output

Example 1 — Basic Case

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

› Output: [4,11]

💡 Note: Between first and second zero: 3+1=4. Between second and third zero: 4+5+2=11. Result is [4,11].

Example 2 — Single Segment

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

› Output: [1,3,4]

💡 Note: Three segments: [1] gives 1, [3] gives 3, [2,2] gives 4. Result is [1,3,4].

Example 3 — Larger Values

$ Input: head = [0,10,20,0,5,15,0]

› Output: [30,20]

💡 Note: First segment: 10+20=30. Second segment: 5+15=20. Result is [30,20].

Constraints

The number of nodes in the list is in the range [3, 2 × 10⁵].
0 ≤ Node.val ≤ 1000
The beginning and end of the linked list have Node.val == 0.
There are no two consecutive nodes with Node.val == 0.

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 f Facebook 32 G Google 28

The key insight is to process segments between zeros in a single pass while building the result. The optimal approach uses in-place modification to transform zero nodes into sum nodes and skip intermediate nodes. Best approach is Single Pass In-Place: Time O(n), Space O(1).

Common Approaches

✓ Single Pass In-Place

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

Traverse the list once, accumulating sums between zeros and modifying nodes in place. When we encounter a zero after collecting a sum, we update the previous zero node with the sum and continue.

Two-Pass Approach

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

Traverse the list twice - first to collect all segment sums, then create a new linked list with those sums. This approach is straightforward but requires extra space and time.

Single Pass In-Place — Algorithm Steps

Start from first zero, track current sum
For each non-zero node, add to current sum
When hitting next zero, set previous zero's value to sum
Remove intermediate nodes by updating pointers

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Sum

Accumulate values between zeros

Update Zero

Replace zero with accumulated sum

Continue

Move to next segment

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) {
    if (!head || !head->next) {
        return NULL;
    }
    
    struct ListNode dummy = {0, NULL};
    struct ListNode* result_tail = &dummy;
    struct ListNode* current = head->next;  // Skip the first zero
    int current_sum = 0;
    
    while (current) {
        if (current->val == 0) {
            // Found a zero, create new node with sum
            if (current_sum > 0) {  // Only create node if we have a sum
                result_tail->next = (struct ListNode*)malloc(sizeof(struct ListNode));
                result_tail->next->val = current_sum;
                result_tail->next->next = NULL;
                result_tail = result_tail->next;
                current_sum = 0;
            }
        } else {
            // Add to current segment sum
            current_sum += current->val;
        }
        current = current->next;
    }
    
    return dummy.next;
}

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    parseArray(line, arr, &size);
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    printf("[");
    struct ListNode* current = result;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        first = 0;
        current = current->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal through the linked list visiting each node once

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for tracking, no extra data structures

✓ Linear Space

68.0K Views

Medium Frequency

~15 min Avg. Time

2.1K 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

Single Pass In-Place — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler