# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 :

 `// C++ implementation to print the sequence  ` `// of burning of nodes of a binary tree ` `#include ` `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& 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<key<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<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<key<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<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<key< 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<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; ` `} `

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.