Remove Zero Sum Consecutive Nodes from Linked List

Remove Zero Sum Consecutive Nodes from Linked List - Problem

Given the head of a linked list, we repeatedly delete consecutive sequences of nodes that sum to 0 until there are no such sequences.

After doing so, return the head of the final linked list. You may return any such answer.

Note that in the examples below, all sequences are serializations of ListNode objects.

Input & Output

Example 1 — Remove Middle Zero Sum

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

› Output: [1,2]

💡 Note: The consecutive nodes 3 and -3 sum to 0, so we remove them. The remaining list is [1,2].

Example 2 — Multiple Removals

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

› Output: [3,1]

💡 Note: First remove [1,2,-3] which sums to 0, leaving [3,1]. No more zero-sum sequences exist.

Example 3 — All Nodes Removed

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

› Output: [1]

💡 Note: Remove [2,3,-3,-2] which sums to 0, leaving [1]. The single node [1] cannot be removed as it doesn't sum to 0.

Constraints

The number of nodes in the given linked list is in the range [1, 1000]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

f Facebook 35 M Microsoft 25 G Google 20

The key insight is using prefix sums to detect zero-sum consecutive sequences efficiently. When the same prefix sum appears twice, the nodes between those positions sum to zero. Best approach uses hash map with O(n) time and O(n) space.

Common Approaches

✓ Brute Force - Check All Subsequences

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

For each starting node, check all possible ending nodes to find consecutive sequences that sum to zero. Remove the first zero-sum sequence found and repeat until no more exist.

Hash Map - Prefix Sum Optimization

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

Calculate prefix sums while traversing the list. When we see the same prefix sum twice, it means the sequence between those points sums to zero. Use a hash map to track the first occurrence of each prefix sum.

Brute Force - Check All Subsequences — Algorithm Steps

Step 1: Start from each node in the list
Step 2: For each starting node, check all possible ending positions
Step 3: Calculate sum of subsequence and remove if it equals zero
Step 4: Repeat until no zero-sum sequences remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Check

Begin from first node, check all subsequences

Find Zero Sum

When sum equals zero, remove that sequence

Repeat

Continue until no more zero-sum sequences exist

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 = malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

int* solution(int* head, int headSize, int* returnSize) {
    if (headSize == 0) {
        *returnSize = 0;
        return malloc(0);  // Return empty array, not NULL
    }
    
    // Convert array to linked list
    struct ListNode* dummy = createNode(0);
    struct ListNode* current = dummy;
    for (int i = 0; i < headSize; i++) {
        current->next = createNode(head[i]);
        current = current->next;
    }
    
    struct ListNode* curr = dummy;
    while (curr->next) {
        struct ListNode* runner = curr->next;
        int total = 0;
        int foundZeroSum = 0;
        
        while (runner) {
            total += runner->val;
            if (total == 0) {
                curr->next = runner->next;
                // Restart from dummy when we find a zero sum
                curr = dummy;
                foundZeroSum = 1;
                break;
            }
            runner = runner->next;
        }
        
        if (!foundZeroSum) {
            // Only advance if we didn't find a zero sum sequence
            curr = curr->next;
        }
    }
    
    // Count result size
    int count = 0;
    for (struct ListNode* node = dummy->next; node != NULL; node = node->next) {
        count++;
    }
    
    // Convert linked list back to array
    *returnSize = count;
    int* result = malloc(count * sizeof(int));
    int i = 0;
    for (struct ListNode* node = dummy->next; node != NULL; node = node->next) {
        result[i++] = node->val;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int head[1000];
    int headSize = 0;
    
    // Parse JSON array
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        int negative = 0;
        if (*p == '-') {
            negative = 1;
            p++;
        }
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        if (negative) num = -num;
        head[headSize++] = num;
    }
    
    int returnSize;
    int* result = solution(head, headSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n nodes, we check up to n subsequences, each taking O(n) time to sum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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 - Check All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler