Merge Nodes in Between Zeros - Practice Coding Problems

Merge Nodes in Between Zeros - Problem

Imagine you have a linked list that acts like a series of compartments separated by walls (zeros). Your task is to merge all items within each compartment and remove the walls!

Given the head of a linked list containing integers, where 0s act as separators, you need to:

Sum all nodes between each pair of consecutive zeros
Replace each group with a single node containing the sum
Remove all zeros from the final result

The input list is guaranteed to start and end with 0, ensuring clean boundaries for your merging operation.

Goal: Return the head of the modified linked list with merged sums and no zeros.

Input & Output

example_1.py — Basic Case

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

› Output: [4,11]

💡 Note: First segment between zeros: 3+1=4. Second segment: 4+5+2=11. Remove all zeros and return merged list.

example_2.py — Single Elements

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

› Output: [1,3,4]

💡 Note: Three segments: first has 1, second has 3, third has 2+2=4. Each segment creates one merged node.

example_3.py — Large Numbers

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

› Output: [30,45]

💡 Note: First segment: 10+20=30. Second segment: 5+15+25=45. Shows the algorithm works with larger values.

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 consecutive zeros in the input except at the boundaries

Visualization

Tap to expand

Understanding the Visualization

Start After First Wall

Begin processing from the first item after the initial wall (zero)

Accumulate Section Items

Keep a running total of all items in the current section

Hit Wall - Consolidate

When we hit a wall (zero), create a consolidated box with the total

Reset and Continue

Reset our counter and continue to the next section

Final Result

End with a clean warehouse containing only consolidated boxes

Key Takeaway

🎯 Key Insight: Single pass with running sum eliminates the need for multiple traversals, making the solution both time and space optimal

Asked in

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

The optimal solution uses a single pass traversal with a running sum. As we traverse the linked list, we accumulate values until hitting a zero, then create a new node with the sum. This achieves O(n) time complexity and O(1) extra space, making it the most efficient approach for this linked list manipulation problem.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Optimal Solution	O(n)	O(1)	Traverse list once, accumulating sums and creating nodes on-the-fly

Single Pass Optimal Solution — Algorithm Steps

Initialize a dummy head for the result list
Skip the initial zero and start processing
Maintain a running sum while traversing non-zero nodes
When encountering a zero, create a new node with current sum
Reset sum and continue until list ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up dummy head and running sum counter

Accumulate

Add non-zero values to running sum

Create Node

When hitting zero, create node with sum and reset

Continue

Repeat until end of list

Code -

solution.c — C

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

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

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

struct ListNode* mergeNodes(struct ListNode* head) {
    struct ListNode* dummy = createNode(0);
    struct ListNode* current = dummy;
    
    // Skip the first zero
    struct ListNode* node = head->next;
    int currentSum = 0;
    
    while (node) {
        if (node->val == 0) {
            // End of current segment, create new node
            current->next = createNode(currentSum);
            current = current->next;
            currentSum = 0;
        } else {
            // Add to current segment sum
            currentSum += node->val;
        }
        
        node = node->next;
    }
    
    return dummy->next;
}

int main() {
    // Test the function
    struct ListNode* head = createNode(0);
    head->next = createNode(3);
    head->next->next = createNode(1);
    head->next->next->next = createNode(0);
    head->next->next->next->next = createNode(4);
    head->next->next->next->next->next = createNode(5);
    head->next->next->next->next->next->next = createNode(2);
    head->next->next->next->next->next->next->next = createNode(0);
    
    struct ListNode* result = mergeNodes(head);
    while (result) {
        printf("%d ", result->val);
        result = result->next;
    }
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the entire linked list, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and running sum variable

✓ Linear Space

89.3K Views

Medium Frequency

~12 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler