Print the Forests of a Binary Tree after removal of given Nodes

Given a Binary Tree and an array arr[] consisting of values of nodes to be deleted, the task is to print Inorder Traversal of the forests after deleting the nodes.

Examples:

Input: arr[] = {10, 5} 

        10
       /  \
      20   30
     / \    \
    4   5    7

Output:
4 20 
30 7
Input: arr[] = {5} 

         1
       /   \
      5     6
     /       \
    10       12

Output:
10 
1 6 12

Approach: Follow the below steps to solve the problem:

1. Perform the Postorder Traversal of the Binary Tree.
2. For each node, check if it contains the value to be deleted.
3. If found to be true, store its child as the root of the forest. Print the forest by Inorder Traversal.

Below is the implementation of the above approach:

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Stores the nodes to be deleted
unordered_map<int, bool> mp;

// Structure of a Tree node
struct Node {
    int key;
    struct Node *left, *right;
};

// Function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return (temp);
}

// Function to check whether the node
// needs to be deleted or not
bool deleteNode(int nodeVal)
{
    return mp.find(nodeVal) != mp.end();
}

// Function to perform tree pruning
// by performing post order traversal
Node* treePruning(Node* root, vector<Node*>& result)
{
    if (root == NULL)
        return NULL;

    root->left = treePruning(root->left, result);
    root->right = treePruning(root->right, result);

    // If the node needs to be deleted
    if (deleteNode(root->key)) {

        // Store the its subtree
        if (root->left) {
            result.push_back(root->left);
        }
        if (root->right) {
            result.push_back(root->right);
        }
        return NULL;
    }

    return root;
}

// Perform Inorder Traversal
void printInorderTree(Node* root)
{
    if (root == NULL)
        return;

    printInorderTree(root->left);
    cout << root->key << " ";
    printInorderTree(root->right);
}

// Function to print the forests
void printForests(Node* root, int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        mp[arr[i]] = true;
    }

    // Stores the remaining nodes
    vector<Node*> result;

    if (treePruning(root, result))
        result.push_back(root);

    // Print the inorder traversal of Forests
    for (int i = 0; i < result.size(); i++) {
        printInorderTree(result[i]);
        cout << endl;
    }
}

// Driver Code
int main()
{

    Node* root = newNode(1);
    root->left = newNode(12);
    root->right = newNode(13);
    root->right->left = newNode(14);
    root->right->right = newNode(15);
    root->right->left->left = newNode(21);
    root->right->left->right = newNode(22);
    root->right->right->left = newNode(23);
    root->right->right->right = newNode(24);

    int arr[] = { 14, 23, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printForests(root, arr, n);
}

Java

// Java Program to implement
// the above approach
import java.util.*;
class GFG{

// Stores the nodes to be deleted
static HashMap<Integer,
                 Boolean> mp  = new HashMap<>();

// Structure of a Tree node
static class Node
{
    int key;
    Node left, right;
};

// Function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return (temp);
}

// Function to check whether the node
// needs to be deleted or not
static boolean deleteNode(int nodeVal)
{
    return mp.containsKey(nodeVal);
}

// Function to perform tree pruning
// by performing post order traversal
static Node treePruning(Node root,
                        Vector<Node> result)
{
    if (root == null)
        return null;

    root.left = treePruning(root.left, result);
    root.right = treePruning(root.right, result);

    // If the node needs to be deleted
    if (deleteNode(root.key))
    {

        // Store the its subtree
        if (root.left != null)
        {
            result.add(root.left);
        }
        if (root.right != null)
        {
            result.add(root.right);
        }
        return null;
    }
    return root;
}

// Perform Inorder Traversal
static void printInorderTree(Node root)
{
    if (root == null)
        return;

    printInorderTree(root.left);
    System.out.print(root.key + " ");
    printInorderTree(root.right);
}

// Function to print the forests
static void printForests(Node root,
                         int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        mp.put(arr[i], true);
    }

    // Stores the remaining nodes
    Vector<Node> result  = new Vector<>();

    if (treePruning(root, result) != null)
        result.add(root);

    // Print the inorder traversal of Forests
    for (int i = 0; i < result.size(); i++)
    {
        printInorderTree(result.get(i));
        System.out.println();
    }
}

// Driver Code
public static void main(String[] args)
{

    Node root = newNode(1);
    root.left = newNode(12);
    root.right = newNode(13);
    root.right.left = newNode(14);
    root.right.right = newNode(15);
    root.right.left.left = newNode(21);
    root.right.left.right = newNode(22);
    root.right.right.left = newNode(23);
    root.right.right.right = newNode(24);

    int arr[] = { 14, 23, 1 };
    int n = arr.length;
    printForests(root, arr, n);
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 Program to implement
# the above approach

# Stores the nodes to be deleted
mp = dict()

# Structure of a Tree node
class Node:

    def __init__(self, key):

        self.key = key
        self.left = None
        self.right = None

# Function to create a new node
def newNode(key):

    temp = Node(key)
    return temp

# Function to check whether the node
# needs to be deleted or not
def deleteNode(nodeVal):

    if nodeVal in mp:
        return True
    else:
        return False

# Function to perform tree pruning
# by performing post order traversal
def treePruning( root, result):

    if (root == None):
        return None;

    root.left = treePruning(root.left, result);
    root.right = treePruning(root.right, result);

    # If the node needs to be deleted
    if (deleteNode(root.key)):

        # Store the its subtree
        if (root.left):
            result.append(root.left);

        if (root.right):
            result.append(root.right);

        return None;

    return root;

# Perform Inorder Traversal
def printInorderTree(root):

    if (root == None):
        return;

    printInorderTree(root.left);
    print(root.key, end=' ')
    printInorderTree(root.right);

# Function to print the forests
def printForests(root, arr, n):
    for i in range(n):
        mp[arr[i]] = True;

    # Stores the remaining nodes
    result = []

    if (treePruning(root, result)):
        result.append(root);

    # Print the inorder traversal of Forests
    for i in range(len(result)):

        printInorderTree(result[i]);
        print()

# Driver Code
if __name__=='__main__':

    root = newNode(1);
    root.left = newNode(12);
    root.right = newNode(13);
    root.right.left = newNode(14);
    root.right.right = newNode(15);
    root.right.left.left = newNode(21);
    root.right.left.right = newNode(22);
    root.right.right.left = newNode(23);
    root.right.right.right = newNode(24);

    arr = [ 14, 23, 1 ]
    n = len(arr)
    printForests(root, arr, n);

# This code is contributed by rutvik_56

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;

class GFG{

// Stores the nodes to be deleted
static Dictionary<int,
                  Boolean> mp = new Dictionary<int,
                                               Boolean>();

// Structure of a Tree node
class Node
{
    public int key;
    public Node left, right;
};

// Function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return (temp);
}

// Function to check whether the node
// needs to be deleted or not
static bool deleteNode(int nodeVal)
{
    return mp.ContainsKey(nodeVal);
}

// Function to perform tree pruning
// by performing post order traversal
static Node treePruning(Node root,
                        List<Node> result)
{
    if (root == null)
        return null;

    root.left = treePruning(root.left, result);
    root.right = treePruning(root.right, result);

    // If the node needs to be deleted
    if (deleteNode(root.key))
    {

        // Store the its subtree
        if (root.left != null)
        {
            result.Add(root.left);
        }
        if (root.right != null)
        {
            result.Add(root.right);
        }
        return null;
    }
    return root;
}

// Perform Inorder Traversal
static void printInorderTree(Node root)
{
    if (root == null)
        return;

    printInorderTree(root.left);
    Console.Write(root.key + " ");
    printInorderTree(root.right);
}

// Function to print the forests
static void printForests(Node root,
                         int []arr, int n)
{
    for(int i = 0; i < n; i++)
    {
        mp.Add(arr[i], true);
    }

    // Stores the remaining nodes
    List<Node> result = new List<Node>();

    if (treePruning(root, result) != null)
        result.Add(root);

    // Print the inorder traversal of Forests
    for(int i = 0; i < result.Count; i++)
    {
        printInorderTree(result[i]);
        Console.WriteLine();
    }
}

// Driver Code
public static void Main(String[] args)
{
    Node root = newNode(1);
    root.left = newNode(12);
    root.right = newNode(13);
    root.right.left = newNode(14);
    root.right.right = newNode(15);
    root.right.left.left = newNode(21);
    root.right.left.right = newNode(22);
    root.right.right.left = newNode(23);
    root.right.right.right = newNode(24);

    int []arr = { 14, 23, 1 };
    int n = arr.Length;
    printForests(root, arr, n);
}
}

// This code is contributed by Amit Katiyar

Javascript

<script>
    // Javascript Program to implement the above approach

    // Stores the nodes to be deleted
    let mp  = new Map();

    // Structure of a Tree node
    class Node
    {
        constructor(key) {
           this.left = this.right = null;
           this.key = key;
        }
    }

    // Function to create a new node
    function newNode(key)
    {
        let temp = new Node(key);
        return (temp);
    }

    // Function to check whether the node
    // needs to be deleted or not
    function deleteNode(nodeVal)
    {
        return mp.has(nodeVal);
    }

    // Function to perform tree pruning
    // by performing post order traversal
    function treePruning(root, result)
    {
        if (root == null)
            return null;

        root.left = treePruning(root.left, result);
        root.right = treePruning(root.right, result);

        // If the node needs to be deleted
        if (deleteNode(root.key))
        {

            // Store the its subtree
            if (root.left != null)
            {
                result.push(root.left);
            }
            if (root.right != null)
            {
                result.push(root.right);
            }
            return null;
        }
        return root;
    }

    // Perform Inorder Traversal
    function printInorderTree(root)
    {
        if (root == null)
            return;

        printInorderTree(root.left);
        document.write(root.key + " ");
        printInorderTree(root.right);
    }

    // Function to print the forests
    function printForests(root, arr, n)
    {
        for (let i = 0; i < n; i++)
        {
            mp.set(arr[i], true);
        }

        // Stores the remaining nodes
        let result  = [];

        if (treePruning(root, result) != null)
            result.push(root);

        // Print the inorder traversal of Forests
        for (let i = 0; i < result.length; i++)
        {
            printInorderTree(result[i]);
            document.write("</br>");
        }
    }

    let root = newNode(1);
    root.left = newNode(12);
    root.right = newNode(13);
    root.right.left = newNode(14);
    root.right.right = newNode(15);
    root.right.left.left = newNode(21);
    root.right.left.right = newNode(22);
    root.right.right.left = newNode(23);
    root.right.right.right = newNode(24);

    let arr = [ 14, 23, 1 ];
    let n = arr.length;
    printForests(root, arr, n);

</script>

Output:

21 
22 
12 
13 15 24

Time Complexity: O(N)
Auxiliary Space: O(N)