Binary Tree Pruning

Binary Tree Pruning - Problem

Given the root of a binary tree, return the same tree where every subtree (of the given tree) not containing a 1 has been removed.

A subtree of a node node is node plus every node that is a descendant of node.

Input & Output

Example 1 — Binary Tree with Mixed Values

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

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

💡 Note: The left subtree (null) is already empty. In the right subtree, the node with value 0 at position [1][0] has a left child 0 (no 1s) which gets removed, but keeps the right child 1. Final tree: [1,null,0,null,1]

Example 2 — Complete Removal

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

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

💡 Note: Left subtree has only 0s, so it's completely removed. Right subtree keeps the path to the 1. The 0 nodes without 1s in their subtrees are pruned away.

Example 3 — All Zeros Except Root

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

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

💡 Note: Most nodes have value 1 so they're kept. Only the leaf nodes with 0 that don't lead to any 1s are removed.

Constraints

The number of nodes in the tree is in the range [1, 200]
Node.val is either 0 or 1

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 18 G Google 15

The key insight is to use post-order DFS traversal to process children before making decisions about the current node. A node should be kept only if it has value 1 OR has at least one child remaining after pruning. Best approach is DFS post-order with Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - Multiple Tree Traversals

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

Visit each node and perform a complete subtree traversal to determine if that subtree contains any 1s. If not, remove the entire subtree. This requires multiple passes through the tree.

DFS Post-Order Traversal

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

Traverse the tree using post-order DFS (left, right, root). For each node, first prune its children, then check if the current node should be kept based on its value and whether it has any remaining children.

Brute Force - Multiple Tree Traversals — Algorithm Steps

Step 1: For each node, traverse its entire subtree
Step 2: Count 1s in the subtree
Step 3: If count is 0, remove the subtree
Step 4: Repeat until no more removals possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Node

For every node, traverse its entire subtree

Count 1s

Count all 1s in the current subtree

Remove if Zero

If no 1s found, remove the entire subtree

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* pruneTree(struct TreeNode* root) {
    if (root == NULL) {
        return NULL;
    }
    
    // Recursively prune left and right subtrees
    root->left = pruneTree(root->left);
    root->right = pruneTree(root->right);
    
    // If current node is 0 and both children are null (pruned), remove this node
    if (root->val == 0 && root->left == NULL && root->right == NULL) {
        free(root);
        return NULL;
    }
    
    return root;
}

struct TreeNode* buildTree(char nodes[][20], int size) {
    if (size == 0 || strcmp(nodes[0], "null") == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(nodes[0]));
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    for (int i = 1; i < size; i += 2) {
        struct TreeNode* parent = queue[front++];
        
        if (i < size && strcmp(nodes[i], "null") != 0) {
            parent->left = createNode(atoi(nodes[i]));
            queue[rear++] = parent->left;
        }
        
        if (i + 1 < size && strcmp(nodes[i + 1], "null") != 0) {
            parent->right = createNode(atoi(nodes[i + 1]));
            queue[rear++] = parent->right;
        }
    }
    
    return root;
}

void treeToArray(struct TreeNode* root, char result[][20], int* size) {
    if (!root) {
        *size = 0;
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    *size = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (node) {
            sprintf(result[(*size)++], "%d", node->val);
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            strcpy(result[(*size)++], "null");
        }
    }
    
    // Remove trailing nulls
    while (*size > 0 && strcmp(result[*size - 1], "null") == 0) {
        (*size)--;
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    if (strlen(input) == 0 || strcmp(input, "[]") == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Parse input
    char nodes[100][20];
    int count = 0;
    
    // Remove brackets
    char* start = input + 1;
    char* end = input + strlen(input) - 1;
    *end = '\0';
    
    if (strlen(start) > 0) {
        char* token = strtok(start, ",");
        while (token != NULL && count < 100) {
            // Trim whitespace
            while (*token == ' ') token++;
            char* trimEnd = token + strlen(token) - 1;
            while (trimEnd > token && *trimEnd == ' ') *trimEnd-- = '\0';
            
            strcpy(nodes[count], token);
            count++;
            token = strtok(NULL, ",");
        }
    }
    
    struct TreeNode* root = buildTree(nodes, count);
    struct TreeNode* result = pruneTree(root);
    
    if (result == NULL) {
        printf("[]\n");
        return 0;
    }
    
    char output[100][20];
    int outputSize;
    treeToArray(result, output, &outputSize);
    
    printf("[");
    for (int i = 0; i < outputSize; i++) {
        if (i > 0) printf(",");
        printf("%s", output[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each node, we traverse its entire subtree, leading to n nodes × n traversals

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force - Multiple Tree Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler