Delete Tree Nodes - Practice Coding Problems

Delete Tree Nodes - Problem

Delete Tree Nodes

You're given a tree with n nodes rooted at node 0. Each node has a value, and you need to remove entire subtrees whose sum equals zero.

The tree is represented by:
• nodes - the total number of nodes
• value[i] - the value of the i-th node
• parent[i] - the parent of the i-th node (parent[0] = -1 for root)

Goal: Remove all subtrees with zero sum and return the count of remaining nodes.

Example: If a subtree has nodes with values [3, -2, -1], the sum is 0, so we remove the entire subtree including all its descendants.

Input & Output

example_1.py — Basic Tree Pruning

$ Input: nodes = 7, parent = [-1,0,0,1,1,2,2], value = [1,-2,4,1,1,-2,2]

› Output: 2

💡 Note: Node 2 has children 5(-2) and 6(2), so subtree sum = 4 + (-2) + 2 = 4 ≠ 0. Node 1 has children 3(1) and 4(1), so subtree sum = (-2) + 1 + 1 = 0, so we remove this entire subtree. Final tree has only nodes 0 and 2 remaining.

example_2.py — Single Node Tree

$ Input: nodes = 1, parent = [-1], value = [0]

› Output: 0

💡 Note: The root node has value 0, so its subtree sum is 0. We remove the entire tree, leaving 0 nodes.

example_3.py — No Pruning Needed

$ Input: nodes = 5, parent = [-1,0,1,2,3], value = [1,2,3,4,5]

› Output: 5

💡 Note: This is a linear tree: 0(1)→1(2)→2(3)→3(4)→4(5). No subtree has sum 0, so all nodes remain.

Constraints

1 ≤ nodes ≤ 10⁴
parent.length == nodes
0 ≤ parent[i] ≤ nodes - 1
parent[0] == -1 which indicates that 0 is the root
value.length == nodes
-10⁵ ≤ value[i] ≤ 10⁵
The given input is guaranteed to represent a valid tree

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Convert parent array into adjacency list representation

Start Post-Order DFS

Begin traversal from root, but process children before parents

Calculate Leaf Sums

Process leaf nodes first - their sum equals their value

Propagate Sums Upward

Each parent sums its value with all children's subtree sums

Prune Zero Subtrees

When subtree sum equals 0, immediately mark entire subtree as removed

Count Remaining Nodes

Return final count of nodes that weren't pruned

Key Takeaway

🎯 Key Insight: Process children before parents (post-order) to calculate subtree sums in one pass, immediately pruning zero-sum subtrees without redundant calculations.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a single post-order DFS traversal to calculate subtree sums bottom-up. For each node, we process all children first, then calculate the current subtree's sum and node count. If the sum equals zero, we return 0 nodes (pruning the entire subtree); otherwise, we return the calculated count. This approach achieves O(n) time complexity with only one tree traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n²)	O(n)	For each node, traverse its entire subtree to calculate sum, then remove if zero
One-Pass DFS (Optimal)	O(n)	O(n)	Single DFS traversal calculating subtree sums bottom-up and pruning immediately

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Build adjacency list representation of the tree
For each node, perform DFS to calculate subtree sum
If subtree sum is zero, mark entire subtree for removal
Count remaining nodes after all removals

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create adjacency list from parent array

Calculate Sums

For each node, traverse entire subtree to get sum

Remove Zero Subtrees

Mark subtrees with zero sum for removal

Count Remaining

Count nodes that weren't removed

Code -

solution.c — C

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

typedef struct {
    int* children;
    int childCount;
    int capacity;
} NodeChildren;

int calculateSum(int node, NodeChildren* nodeChildren, int* value) {
    int total = value[node];
    for (int i = 0; i < nodeChildren[node].childCount; i++) {
        total += calculateSum(nodeChildren[node].children[i], nodeChildren, value);
    }
    return total;
}

int countNodes(int node, NodeChildren* nodeChildren, int* value) {
    if (calculateSum(node, nodeChildren, value) == 0) {
        return 0;
    }
    
    int count = 1;
    for (int i = 0; i < nodeChildren[node].childCount; i++) {
        count += countNodes(nodeChildren[node].children[i], nodeChildren, value);
    }
    return count;
}

int deleteTreeNodes(int nodes, int* parent, int* value) {
    NodeChildren* nodeChildren = malloc(nodes * sizeof(NodeChildren));
    
    for (int i = 0; i < nodes; i++) {
        nodeChildren[i].children = malloc(nodes * sizeof(int));
        nodeChildren[i].childCount = 0;
        nodeChildren[i].capacity = nodes;
    }
    
    for (int i = 1; i < nodes; i++) {
        int p = parent[i];
        nodeChildren[p].children[nodeChildren[p].childCount++] = i;
    }
    
    int result = countNodes(0, nodeChildren, value);
    
    for (int i = 0; i < nodes; i++) {
        free(nodeChildren[i].children);
    }
    free(nodeChildren);
    
    return result;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we might traverse up to n nodes to calculate subtree sum

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

896 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 (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler