Height of Binary Tree After Subtree Removal Queries

Height of Binary Tree After Subtree Removal Queries - Problem

You are given the root of a binary tree with n nodes, where each node has a unique value from 1 to n. You must handle m independent queries, where each query asks: "What would be the height of the tree if I removed the subtree rooted at node X?"

For each query queries[i], you need to:

Temporarily remove the entire subtree rooted at the node with value queries[i]
Calculate the height of the remaining tree
Restore the tree to its original state for the next query

Important: The height of a tree is the number of edges in the longest path from root to any leaf. An empty tree has height -1, and a single node has height 0.

Goal: Return an array where answer[i] is the height of the tree after removing the subtree in query i.

Input & Output

example_1.py — Basic Tree

$ Input: root = [1,3,4,2,null,6,5,null,null,null,null,null,7], queries = [4]

› Output: [2]

💡 Note: The tree has height 3. When we remove the subtree rooted at node 4 (which includes nodes 4, 6, 5, 7), the remaining tree has nodes [1, 3, 2] with height 2 (path: 1→3→2).

example_2.py — Multiple Queries

$ Input: root = [5,8,9,2,1,3,7,4,6], queries = [3,2,4,8]

› Output: [3,2,3,2]

💡 Note: Original tree height is 3. Removing node 3: height becomes 3. Removing node 2: height becomes 2. Removing node 4: height becomes 3. Removing node 8: height becomes 2.

example_3.py — Edge Case

$ Input: root = [1,null,5,3,null,2,4], queries = [3,5,4,2,1]

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

💡 Note: When removing the root node 1, the tree becomes empty (height -1). Other removals leave various subtrees with different heights.

Constraints

The number of nodes in the tree is n
2 ≤ n ≤ 10⁵
1 ≤ Node.val ≤ n
All the values in the tree are unique
1 ≤ queries.length ≤ min(n, 10⁴)
1 ≤ queries[i] ≤ n
queries[i] ≠ root.val

Visualization

Tap to expand

Understanding the Visualization

Survey the Tree

First, measure the height of every branch and note the depth of each node from the root

Plan the Cuts

For each possible branch removal, calculate what the remaining tree height would be

Answer Queries

When asked about removing any specific branch, instantly provide the pre-calculated answer

Key Takeaway

🎯 Key Insight: Instead of recalculating the tree height for each query, we precompute the effect of removing every possible subtree. This transforms an O(n×m) problem into an O(n+m) solution by trading some space for massive time savings.

Asked in

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

The optimal solution uses a two-pass preprocessing approach: first calculate subtree heights and node depths, then determine the tree height after removing each possible subtree. This allows O(1) query answering after O(n) preprocessing, making it much more efficient than the brute force approach for multiple queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate Each Query)	O(m × n)	O(h)	For each query, actually remove the subtree and recalculate the entire tree height
Two-Pass Preprocessing (Optimized)	O(n + m)	O(n)	First pass to calculate subtree heights, second pass to determine removal effects

Brute Force (Simulate Each Query) — Algorithm Steps

For each query, traverse the tree to find the target node to remove
Remove the entire subtree rooted at that node
Calculate the height of the remaining tree using DFS
Restore the original tree structure
Store the result and move to the next query

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Tree

Start with the complete binary tree

Clone Tree

Create a complete copy of the original tree

Remove Subtree

Remove the target node and all its descendants

Calculate Height

Traverse remaining tree to find the maximum depth

Code -

solution.c — C

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

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

int getHeight(struct TreeNode* node) {
    if (!node) return -1;
    int left = getHeight(node->left);
    int right = getHeight(node->right);
    return 1 + (left > right ? left : right);
}

struct TreeNode* removeSubtree(struct TreeNode* node, int target) {
    if (!node) return NULL;
    if (node->val == target) return NULL;
    node->left = removeSubtree(node->left, target);
    node->right = removeSubtree(node->right, target);
    return node;
}

struct TreeNode* cloneTree(struct TreeNode* node) {
    if (!node) return NULL;
    struct TreeNode* clone = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    clone->val = node->val;
    clone->left = cloneTree(node->left);
    clone->right = cloneTree(node->right);
    return clone;
}

int* treeQueries(struct TreeNode* root, int* queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        struct TreeNode* treeCopy = cloneTree(root);
        treeCopy = removeSubtree(treeCopy, queries[i]);
        result[i] = getHeight(treeCopy);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

For each of m queries, we traverse the entire tree of n nodes to remove the subtree and calculate new height

✓ Linear Growth

Space Complexity

O(h)

Recursion stack space where h is the height of the tree

✓ Linear Space

28.4K Views

Medium-High Frequency

~35 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 (Simulate Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler