Table of Contents

Have you ever wondered how long it would take to burn an entire binary tree starting from a leaf node? This intriguing question has puzzled many beginners in the world of data structures and algorithms. In this article, we will explore the concept of burning a binary tree and find out the minimum time it would take to burn the whole tree.

## Understanding the Burning Process

Imagine you have a binary tree, and one leaf node in the tree is set on fire. The fire spreads from one node to another in the next second, which means that any node connected to a burning node will catch fire in the subsequent second. This process continues until the entire tree is burnt.

The objective of this challenge is to determine the minimum time it would take for the entire tree to burn, starting from a given leaf node.

## Finding the Minimum Time

To solve this challenge, we need to find the depth or distance of each node from the starting leaf node. We will start from the leaf node and traverse the tree to find each node’s depth. The depth of a node is defined as the number of edges from the starting leaf node to that node.

Once we have the depth of each node, we can calculate the height of each subtree rooted at those nodes. The height of a subtree is the maximum depth of any node in that subtree. We add the depth and height of each subtree and keep track of the maximum value. This maximum value represents the minimum time it would take for the entire tree to burn.

## The Code Breakdown

Let’s explore the code that solves this burning challenge step by step:

```
static int burn(Node root, int target, Depth d) {
// Base case: if root is null, return 0
if (root == null) {
return 0;
}
// If the current root is the target, set the depth and return 1
if (root.data == target) {
d.D = 1;
return 1;
}
// Recursively call for the left and right subtrees
Depth LD = new Depth(-1);
Depth RD = new Depth(-1);
int LH = burn(root.left, target, LD);
int RH = burn(root.right, target, RD);
// If target is found on the left side, update the answer
if (LD.D != -1) {
answer = Math.max(answer, LD.D + 1 + RH);
}
// If target is found on the right side, update the answer
if (RD.D != -1) {
answer = Math.max(answer, RD.D + 1 + LH);
}
// Update the depth of the current root node
d.D = Math.max(LD.D, RD.D) + 1;
// Return the height of the subtree rooted at the current node
return Math.max(LH, RH) + 1;
}
```

In this code snippet, we have a `burn()`

function that takes in the root node of the binary tree, the target leaf node, and an object of the `Depth`

class. This `Depth`

class is essentially a wrapper class that holds the depth value.

The `burn()`

function follows a recursive approach. It first checks the base case, where if the root is null, it returns 0. Next, it checks if the current root is the target leaf node. If it is, it sets the depth to 1 and returns 1.

If the target is not found at the current root, the function calls itself recursively for the left and right subtrees. It creates two instances of the `Depth`

class to store the depths of the left and right subtrees.

After getting the depths of the left and right subtrees, the function checks if the target leaf node is found on either side. If it is, it updates the answer by adding the depth, 1 for the current root, and the height from the other side.

Finally, the function updates the depth of the current root by taking the maximum depth between the left and right subtrees and adding 1. It then returns the height of the subtree rooted at the current node, which is the maximum height between the left and right subtrees plus 1.

## Conclusion

By using the `burn()`

function described above, we can easily determine the minimum time it would take to burn a binary tree starting from a given leaf node. This approach utilizes the depths and heights of the nodes and subtrees to calculate the answer.

If you find this topic fascinating, keep exploring more advanced concepts in binary trees and try implementing them in your own code. Happy burning!

*This article is brought to you by Q Nails and Spa, your go-to destination for nail and spa services.*