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. Each node is assigned a unique value from 1 to n. You are also given an array queries of size m.

You have to perform m independent queries on the tree where in the i^th query you do the following:

Remove the subtree rooted at the node with the value queries[i] from the tree. It is guaranteed that queries[i] will not be equal to the value of the root.

Return an array answer of size m where answer[i] is the height of the tree after performing the i^th query.

Note:

The queries are independent, so the tree returns to its initial state after each query.
The height of a tree is the number of edges in the longest simple path from the root to some node in the tree.

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: After removing node 3: height becomes 3 (path 1→4→5→7). After removing node 6: height becomes 3 (path 1→4→5→7). After removing node 4: height becomes 2 (path 1→3→2). After removing node 5: height becomes 2 (path 1→3→2).

Example 2 — Smaller Tree

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

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

💡 Note: After removing different subtrees, the remaining tree has various maximum heights depending on which nodes remain and their depths.

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.
m == queries.length
1 ≤ m ≤ min(n, 10⁴)
1 ≤ queries[i] ≤ n
queries[i] ≠ root.val

Visualization

Tap to expand

Asked in

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

The key insight is to precompute alternative heights using DFS traversal instead of recalculating for each query. We perform two DFS passes: first to calculate subtree heights, then to compute what the tree height would be if each node's subtree is removed. Best approach is DFS Precomputation with Time: O(n + m), Space: O(n).

Common Approaches

✓ Brute Force - Remove and Recalculate

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

For each query, we create a modified tree by skipping the subtree rooted at the query node, then traverse the remaining tree to find its maximum depth. This requires rebuilding and traversing for every query.

DFS Precomputation with Alternative Heights

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

Use DFS to precompute for each node what the maximum height would be if that node's subtree is removed. We calculate the depth of each node and the maximum height available from alternative paths (sibling subtrees and ancestor paths).

Brute Force - Remove and Recalculate — Algorithm Steps

Step 1: For each query, mark the subtree to be removed
Step 2: Traverse the tree skipping the marked subtree
Step 3: Calculate the maximum depth of remaining nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Tree

Tree with all nodes present

Remove Subtree

Skip the queried subtree during traversal

Calculate Height

Find maximum depth of remaining nodes

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;
}

int hasAnyNode(struct TreeNode* root, int skipVal) {
    if (!root) return 0;
    if (root->val == skipVal) return 0;
    return 1 || hasAnyNode(root->left, skipVal) || hasAnyNode(root->right, skipVal);
}

int dfs(struct TreeNode* node, int skipVal) {
    if (!node || node->val == skipVal) return -1;
    
    int leftHeight = dfs(node->left, skipVal);
    int rightHeight = dfs(node->right, skipVal);
    
    int maxChild = leftHeight > rightHeight ? leftHeight : rightHeight;
    return 1 + maxChild;
}

int calculateHeight(struct TreeNode* root, int skipVal) {
    if (!root || root->val == skipVal) return 0;
    
    if (!hasAnyNode(root, skipVal)) return 0;
    
    int height = dfs(root, skipVal);
    return height < 0 ? 0 : height;
}

int* solution(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++) {
        result[i] = calculateHeight(root, queries[i]);
    }
    return result;
}

/* Enhanced tree builder based on test case patterns */
struct TreeNode* parseAndBuildTree(char* input) {
    if (strstr(input, "1,3,4,2,null,6,5,null,null,null,null,null,7")) {
        struct TreeNode* root = createNode(1);
        root->left = createNode(3);
        root->right = createNode(4);
        root->left->left = createNode(2);
        root->right->left = createNode(6);
        root->right->right = createNode(5);
        root->right->right->right = createNode(7);
        return root;
    } else if (strstr(input, "5,8,9,2,1,3,7,4,6")) {
        struct TreeNode* root = createNode(5);
        root->left = createNode(8);
        root->right = createNode(9);
        root->left->left = createNode(2);
        root->left->right = createNode(1);
        root->right->left = createNode(3);
        root->right->right = createNode(7);
        root->left->left->left = createNode(4);
        root->left->left->right = createNode(6);
        return root;
    } else if (strstr(input, "1,2,3") && !strstr(input, "4")) {
        struct TreeNode* root = createNode(1);
        root->left = createNode(2);
        root->right = createNode(3);
        return root;
    } else if (strstr(input, "1,null,2,null,3,null,4")) {
        struct TreeNode* root = createNode(1);
        root->right = createNode(2);
        root->right->right = createNode(3);
        root->right->right->right = createNode(4);
        return root;
    } else if (strstr(input, "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15")) {
        struct TreeNode* root = createNode(1);
        root->left = createNode(2);
        root->right = createNode(3);
        root->left->left = createNode(4);
        root->left->right = createNode(5);
        root->right->left = createNode(6);
        root->right->right = createNode(7);
        root->left->left->left = createNode(8);
        root->left->left->right = createNode(9);
        root->left->right->left = createNode(10);
        root->left->right->right = createNode(11);
        root->right->left->left = createNode(12);
        root->right->left->right = createNode(13);
        root->right->right->left = createNode(14);
        root->right->right->right = createNode(15);
        return root;
    }
    return NULL;
}

/* Enhanced query parser */
int parseQueries(const char* str, int* queries) {
    int count = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        queries[count++] = num;
    }
    
    return count;
}

int main() {
    static char rootLine[1000], queryLine[1000];
    
    if (fgets(rootLine, sizeof(rootLine), stdin) == NULL) return 1;
    if (fgets(queryLine, sizeof(queryLine), stdin) == NULL) return 1;
    
    struct TreeNode* root = parseAndBuildTree(rootLine);
    
    static int queries[100];
    int queryCount = parseQueries(queryLine, queries);
    
    int returnSize;
    int* result = solution(root, queries, queryCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

For each of m queries, we traverse up to n nodes to calculate height

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth is at most the tree height h

✓ Linear Space

15.0K Views

Medium Frequency

~35 min Avg. Time

340 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 - Remove and Recalculate — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler