Delete Nodes And Return Forest - Practice Coding Problems

Delete Nodes And Return Forest - Problem

Imagine you have a binary tree representing a family tree or organizational structure, and you need to remove certain nodes while preserving the remaining structure. When nodes are deleted, their children become the roots of new, separate trees - creating what we call a forest.

Given the root of a binary tree where each node has a distinct value, and an array to_delete containing values of nodes to remove, your task is to:

Delete all nodes whose values appear in the to_delete array
Return the roots of all remaining trees in the resulting forest
When a node is deleted, its children (if any) become new tree roots

Example: If you delete the root of a tree, its left and right children become separate tree roots. The order of the returned roots doesn't matter.

Input & Output

example_1.py — Basic Tree Deletion

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

› Output: [[1,2,null,4],[6],[7]]

💡 Note: Deleting nodes 3 and 5 creates three separate trees: the main tree with root 1 (node 3's children 6,7 become separate roots), and isolated nodes 6 and 7 as single-node trees.

example_2.py — Root Deletion

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

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

💡 Note: When the root node 1 is deleted, its children (2 and 4) become the roots of new trees in the forest. Node 2 keeps its child 3.

example_3.py — Single Node Tree

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

› Output: []

💡 Note: Edge case: deleting the only node in the tree results in an empty forest (no remaining trees).

Constraints

The number of nodes in the given tree is at most 1000
Each node has a distinct value
1 ≤ Node.val ≤ 1000
1 ≤ to_delete.length ≤ 1000
All values in to_delete are unique

Visualization

Tap to expand

Understanding the Visualization

Original Forest

Start with a connected tree structure

Mark for Deletion

Identify nodes to delete using hash set lookup

Perform Deletions

Remove marked nodes, creating gaps in the tree

Identify New Roots

Children of deleted nodes become new forest roots

Return Forest

Collect all independent tree roots

Key Takeaway

🎯 Key Insight: Use a hash set for O(1) deletion checks and single DFS pass where each node determines if it becomes a forest root based on its survival and parent's deletion status.

Asked in

f Facebook 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

The optimal solution uses a single DFS traversal with a hash set for O(1) deletion lookups. Each node determines if it becomes a forest root by checking: (1) it survives deletion, and (2) its parent was deleted or it's the original root. This achieves O(n) time complexity with elegant recursive logic.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n × m)	O(h + r)	Delete nodes one by one, rebuilding the tree structure after each deletion
One-Pass DFS with Hash Set (Optimal)	O(n)	O(h + m + r)	Single DFS traversal using hash set lookup for O(1) deletion checks

Brute Force (Multiple Tree Traversals) — Algorithm Steps

For each value in to_delete array, traverse the entire tree to find the node
Remove the found node and handle its children
After each deletion, traverse again to collect current forest roots
Repeat until all deletions are complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Tree

Start with the original tree structure

First Deletion Search

Traverse entire tree to find first node to delete

Delete and Collect

Remove node and collect new roots

Repeat Process

Repeat for each remaining deletion target

Code -

solution.c — C

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

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

bool findAndDelete(struct TreeNode* node, int target, struct TreeNode* parent, bool isLeft) {
    if (!node) return false;
    
    if (node->val == target) {
        if (parent) {
            if (isLeft) parent->left = NULL;
            else parent->right = NULL;
        }
        return true;
    }
    
    return findAndDelete(node->left, target, node, true) ||
           findAndDelete(node->right, target, node, false);
}

struct TreeNode** delNodes(struct TreeNode* root, int* to_delete, int to_deleteSize, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    struct TreeNode** currentRoots = malloc(1000 * sizeof(struct TreeNode*));
    currentRoots[0] = root;
    int currentSize = 1;
    
    for (int i = 0; i < to_deleteSize; i++) {
        int target = to_delete[i];
        struct TreeNode** newRoots = malloc(1000 * sizeof(struct TreeNode*));
        int newSize = 0;
        
        for (int j = 0; j < currentSize; j++) {
            if (currentRoots[j]->val == target) {
                if (currentRoots[j]->left) {
                    newRoots[newSize++] = currentRoots[j]->left;
                }
                if (currentRoots[j]->right) {
                    newRoots[newSize++] = currentRoots[j]->right;
                }
            } else {
                findAndDelete(currentRoots[j], target, NULL, false);
                newRoots[newSize++] = currentRoots[j];
            }
        }
        
        free(currentRoots);
        currentRoots = newRoots;
        currentSize = newSize;
    }
    
    *returnSize = currentSize;
    return currentRoots;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n is number of nodes, m is length of to_delete array. We traverse the tree m times.

✓ Linear Growth

Space Complexity

O(h + r)

h is height for recursion stack, r is number of resulting forest roots

✓ Linear Space

72.5K Views

Medium-High Frequency

~25 min Avg. Time

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