Burn the binary tree starting from the target node

Given a binary tree and target node. By giving the fire to the target node and fire starts to spread in a complete tree. The task is to print the sequence of the burning nodes of a binary tree.

Rules for burning the nodes :

  • Fire will spread constantly to the connected nodes only.
  • Every node takes the same time to burn.
  • A node burns only once.

Examples:



Input : 
                       12
                     /     \
                   13       10
                          /     \
                       14       15
                      /   \     /  \
                     21   24   22   23
target node = 14

Output :
14
21, 24, 10
15, 12
22, 23, 13

Explanation : First node 14 burns then it gives fire to it's 
neighbors(21, 24, 10) and so on. This process continues until 
the whole tree burns.


Input :
                       12
                     /     \
                  19        82
                 /        /     \
               41       15       95
                 \     /         /  \
                  2   21        7   16
target node = 41

Output :
41
2, 19
12
82
15, 95
21, 7, 16

Approach :
First search the target node in a binary tree recursively. After finding the target node print it and save its left child(if exist) and right child(if exist) in a queue. and return. Now, get the size of the queue and run while loop. Print elements in the queue.

Below is the implementation of the above approach :

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to print the sequence 
// of burning of nodes of a binary tree
#include <bits/stdc++.h>
using namespace std;
  
// A Tree node
struct Node {
    int key;
    struct Node *left, *right;
};
  
// Utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return (temp);
}
  
// Utility function to print the sequence of burning nodes
int burnTreeUtil(Node* root, int target, queue<Node*>& q)
{
    // Base condition
    if(root == NULL)
    {
        return 0;
    }
      
    // Condition to check whether target 
    // node is found or not in a tree
    if(root->key == target)
    {
        cout<<root->key<<endl;
        if(root->left != NULL)
        {
            q.push(root->left);
        }
        if(root->right != NULL)
        {
  
            q.push(root->right);
        }
          
        // Return statements to prevent
        // further function calls
        return 1;
    }
      
    int a = burnTreeUtil(root->left, target, q);
          
    if(a == 1)
    {
        int qsize = q.size();
          
        // Run while loop until size of queue
        // becomes zero
        while(qsize--)
        {
            Node* temp = q.front();
              
            // Printing of burning nodes
            cout<<temp->key<<" , ";
            q.pop();
              
            // Check if condition for left subtree
            if(temp->left != NULL)
                q.push(temp->left);
                  
            //Check if condition for right subtree
            if(temp->right != NULL)
                    q.push(temp->right);
        }
              
        if(root->right != NULL)
            q.push(root->right);
  
        cout<<root->key<<endl;
              
        // Return statement it prevents further
        // further function call
            return 1;
    }
      
    int b = burnTreeUtil(root->right, target, q);
      
    if(b == 1)
    {
        int qsize = q.size();
        // Run while loop until size of queue
        // becomes zero
              
        while(qsize--)
        {
            Node* temp = q.front();
                  
            //Printing of burning nodes
            cout<<temp->key<<" , ";
            q.pop();
                  
            //Check if condition for left subtree
            if(temp->left != NULL)
                q.push(temp->left);
                  
            //Check if condition for left subtree
            if(temp->right != NULL)
                q.push(temp->right);
        }
          
        if(root->left != NULL)
            q.push(root->left);
      
        cout<<root->key<<endl;
          
        // Return statement it prevents further
        // further function call
        return 1;
  
    }
}
  
//Function will print the sequence of burning nodes
void burnTree(Node* root, int target)
{
    queue<Node*> q;
      
    //Function call
    burnTreeUtil(root, target, q);
      
    //While loop runs unless queue becomes empty
    while(!q.empty())
    {
        Node* temp = q.front();
          
        //Printing of burning nodes
        cout<<temp->key;
          
        if(q.size()!=1)
            cout << " , ";
        q.pop();
    }
}
  
// Driver Code
int main()
{
 /* 10
    / \
    12 13
      /  \
    14   15
   / \   / \
  21 22 23 24
  
    Let us create Binary Tree as shown
    above */
  
    Node* root = newNode(10);
    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 targetNode = 14;
      
    // Function call
    burnTree(root, targetNode);
  
    return 0;
}

chevron_right


Output:

14
21 , 22 , 13
15 , 10
23 , 24 , 12


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :
Practice Tags :


3


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.