Binary Tree Pruning - Practice Coding Problems

Binary Tree Pruning - Problem

Imagine you have a binary tree where each node contains either 0 or 1. Your task is to prune this tree by removing all subtrees that don't contain at least one 1.

Think of it like trimming a plant - you want to cut off all the branches that don't have any fruit (represented by 1s). A subtree is considered "fruitless" if it contains only 0s.

What you need to do:

Given the root of a binary tree with 0s and 1s
Remove every subtree that contains only 0s
Return the pruned tree
A subtree includes a node and all its descendants

Key insight: If a subtree has no 1s anywhere in it, the entire subtree should be removed!

Input & Output

example_1.py — Basic Tree Pruning

$ Input: [1,null,0,0,1]

› Output: [1,null,0,null,1]

💡 Note: The left subtree of the right child (which was [0,0,null]) contained only zeros and was pruned. The right child itself (0) was kept because its right subtree contains a 1.

example_2.py — Root Pruning

$ Input: [1,0,1,0,0,0,1]

› Output: [1,null,1,null,1]

💡 Note: The entire left subtree [0,0,0] contained only zeros and was pruned. From the right subtree, only the path leading to 1 was preserved.

example_3.py — Complete Tree Removal

$ Input: [0,0,0]

› Output: []

💡 Note: The entire tree contains only zeros, so everything gets pruned, resulting in an empty tree (null root).

Visualization

Tap to expand

Understanding the Visualization

Start at Leaves

Begin at the bottom of the tree, examining leaf nodes first

Remove Zero Leaves

Cut off any leaf nodes that contain 0 (no fruit)

Move Up Tree

After pruning children, examine parent nodes

Prune Empty Branches

If a node has value 0 and no children left, remove it too

Preserve Paths to 1s

Keep any branch that leads to a 1, even if it contains 0s along the way

Key Takeaway

🎯 Key Insight: Post-order traversal ensures we process children before parents, allowing optimal pruning decisions in a single pass through the tree.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in post-order traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 200]
Node.val is either 0 or 1
Key constraint: Only subtrees containing exclusively 0s should be pruned

Asked in

f Facebook 25 G Google 18 a Amazon 12 ⊞ Microsoft 8

The optimal approach uses post-order DFS traversal to solve this problem in O(n) time with a single pass. The key insight is to process children before their parent, allowing us to make pruning decisions based on already-processed subtrees. If a node has value 0 and no remaining children after pruning, we remove it. This bottom-up approach ensures we never do redundant work and efficiently prunes all zero-only subtrees.

Common Approaches

Approach	Time	Space	Notes
✓ Post-Order DFS (Optimal)	O(n)	O(h)	Single pass using post-order traversal to prune from leaves up to root
Brute Force (Multiple Tree Traversals)	O(n²)	O(h)	Repeatedly traverse the tree to find and remove subtrees with only zeros

Post-Order DFS (Optimal) — Algorithm Steps

Use post-order DFS to visit children before parent
Recursively prune left and right subtrees first
After processing children, check current node
If current node is 0 and has no children, prune it
Return the pruned node (or null if pruned)

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Leaves First

Start at leaves and process children before parents

Prune Zero Leaves

Remove leaf nodes with value 0

Work Upward

Move up the tree, making decisions based on pruned children

Final Result

Return the root of the pruned tree

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* pruneTree(struct TreeNode* root) {
    if (!root) return NULL;
    
    // Post-order: process children first
    root->left = pruneTree(root->left);
    root->right = pruneTree(root->right);
    
    // If current node is 0 and has no children, prune it
    if (root->val == 0 && !root->left && !root->right) {
        return NULL;
    }
    
    return root;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in post-order traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 200]
Node.val is either 0 or 1
Key constraint: Only subtrees containing exclusively 0s should be pruned

94.5K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Post-Order DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler