Burn the Binary tree from the Target node

What is a Binary tree?

The binary tree is a type of generic tree where one node can have a maximum of two child nodes. We are given a binary tree and target node. We have to burn the binary tree starting from the target node and print the nodes burnt at each level.

Burning means at time = 0 target node will burn, and then the parent and its child node will be burnt.

For example:

At level 0: The burning node is 5.

Burn the Binary tree from the Target node

At level 1: The burning nodes are 2 and 7.

At level 2: The burning nodes are 1, 4 and 9.

At level 3: The burning node is 3.

At level 4: The burning node is 6.

At level 5: The burning node is 8.

Method 1

In this approach, our first task will be to get the target node. So recursively, we will search for the target node. After finding the target node, we will print the node and then we will add its left and right children into the queue.

For each node, we will call the recursive function for its left and right subtree. If the recursive function returns one, which means in that subtree, we found the target node, so we will print the elements present in the queue and then we will print the current node.

In the main function after this recursive call, we will check if there are some nodes remaining or not by checking the queue size. We will print the elements present in the queue.

Java code:

import java.util.*;
 public class Main{
     public static class Node{
         int data;
         Node left;
         Node right;
         Node(int data){
             this.data=data;
             this.left=null;
             this.right=null;
         }
     }
     public static Queue<Node> q;
     public static void main(String[] args){
         
         Node root=new Node(1);
         root.left=new Node(2);
         root.right=new Node(3);
         root.left.left=new Node(4);
         root.left.right=new Node(5);
         root.right.right=new Node(6);
         root.left.right.left=new Node(7);
         root.right.right.left=new Node(8);
         root.left.right.left.right=new Node(9);
         
         int target=5;
         q=new ArrayDeque<>();
         burnTree(root,target);
         while(!q.isEmpty()){
             int k=q.size();
             while(k-- >0){
                  Node top=q.poll();
                 System.out.print(top.data+" ");
                 if(top.left!=null)
                 q.add(top.left);
                 if(top.right!=null)
                 q.add(top.right);
             }
             System.out.println();
         }
         
     }
     public static int burnTree(Node root,int target){
         if(root==null)
         return 0;
         if(root.data==target){
             System.out.println(target);
             if(root.left!=null)
             q.add(root.left);
             if(root.right!=null)
             q.add(root.right);
             return 1;
         }
         
         int leftCall = burnTree(root.left,target);
         if(leftCall == 1){
             int k = q.size();
             while(k-- >0){
                 Node top=q.poll();
                 System.out.print(top.data+" ");
                 if(top.left!=null)
                 q.add(top.left);
                 if(top.right!=null)
                 q.add(top.right);
             }
             if(root.right!=null)
             q.add(root.right);
             System.out.println(root.data);
             return 1;
         }
         
         int rightCall = burnTree(root.right,target);
         if(rightCall == 1){
             int k = q.size();
             while(k-- >0){
                 Node top=q.poll();
                 System.out.print(top.data+" ");
                 if(top.left!=null)
                 q.add(top.left);
                 if(top.right!=null)
                 q.add(top.right);
             }
             if(root.left!=null)
             q.add(root.left);
             System.out.println(root.data);
             return 1;
         }
         return 0;
     }
 }

Output:

Time complexity: O(N), where N is the number of nodes.

Space complexity: O(N) for queue.

Method 2

The second approach is to convert the given binary tree into an undirected graph. Then after converting the tree into a graph, we will use the BFS approach to burn the nodes.

For each node, we have its children and the parent so we will convert the parents and children as the neighbor nodes for any particular node.

We will use the queue data structure to get the Breadth First search of the given graph.

We will use a hashmap of nodes vs ArrayList of nodes which will contain the list of neighbors of each node we can access in constant time.

Java code:

import java.util.*;
 public class Main{
     public static class Node{
         int data;
         Node left;
         Node right;
         Node(int data){
             this.data=data;
             this.left=null;
             this.right=null;
         }
     }
    
     public static void main(String[] args){
         
         Node root=new Node(1);
         root.left=new Node(2);
         root.right=new Node(3);
         root.left.left=new Node(4);
         root.left.right=new Node(5);
         root.right.right=new Node(6);
         root.left.right.left=new Node(7);
         root.right.right.left=new Node(8);
         root.left.right.left.right=new Node(9);
         Node target= root.left.right; // node 5
         burnBinaryTree(root,target);
         
     }
     public static void burnBinaryTree(Node root,Node target){
         List<Integer> result= new ArrayList<>();
         HashMap<Node,List<Node>> map = new HashMap<>();
         if(root == null)
         return;
         treeToGraph(root,null,map);
         if(map.containsKey(target) == false){
             System.out.println(" target node is not presented in the tree");
             return;
         }
         
         HashSet<Node> visited = new HashSet<>();
         Queue<Node> q = new ArrayDeque<>();
         q.add(target);
         visited.add(target);
         while(q.size()>0){
             int k =q.size();
             while(k-- >0){
                 Node top=q.poll();
                 System.out.print(top.data+" ");
                 for(Node nbr:map.get(top)){
                     if(visited.contains(nbr) == false){
                         visited.add(nbr);
                         q.add(nbr);
                     }
                 }
             }
             System.out.println();
         }
     }
     public static void treeToGraph(Node node,Node parent,HashMap<Node,List<Node>> map){
         if(node == null)
         return;
         
         if(map.containsKey(node)==false){
             map.put(node,new ArrayList<Node>());
         }
         if(parent!=null){
             map.get(parent).add(node);
             map.get(node).add(parent);
         }
         treeToGraph(node.left,node,map);
         treeToGraph(node.right,node,map);
     }
 }

Output: