## Similar Problems

Similar Problems not available

# Step By Step Directions From A Binary Tree Node To Another - Leetcode Solution

## Companies:

LeetCode: Step By Step Directions From A Binary Tree Node To Another Leetcode Solution

Difficulty: Medium

Topics: string tree binary-tree depth-first-search

Step By Step Directions From A Binary Tree Node To Another problem on leetcode asks us to write a function that finds the shortest path from a given node to another node in a binary tree and returns the path as an array of strings, where each string represents a move from one node to another.

To solve this problem, we can use a modified Breadth-First Search (BFS) algorithm to traverse the binary tree and keep track of the path from the start node to the target node. The BFS algorithm allows us to find the shortest path between the start node and the target node.

Here are the steps to solve the problem:

Step 1: Create a function `path_from_node_to_node`

that takes two arguments, `root`

and `p`

(the start node), and `q`

(the target node), where `root`

is the root of the binary tree.

Step 2: Initialize a queue `queue`

and a dictionary `parent`

to keep track of the parent of each node in the binary tree. Add the `p`

node to the `queue`

and set its parent to `None`

.

Step 3: While the `queue`

is not empty, dequeue the first element from the `queue`

and check if it is equal to `q`

(the target node). If it is, then we have found the target node. We can then reconstruct the path from the start node to the target node using the `parent`

dictionary, and return it as an array of strings.

Step 4: Otherwise, if the dequeued node is not equal to `q`

, then we enqueue its left and right children (if they exist) to the `queue`

, and set their parent in the `parent`

dictionary.

Step 5: Repeat steps 3 and 4 until we find the target node.

Step 6: If we reach the end of the BFS traversal and do not find the target node, this means that the target node is not in the binary tree. In this case, we return an empty array.

Here is the Python code that implements the above algorithm:

```
def path_from_node_to_node(root, p, q):
queue = []
parent = {p: None}
queue.append(p)
while queue:
node = queue.pop(0)
if node == q:
path = []
while node:
path.append(node)
node = parent[node]
path.reverse()
return [f"Left" if parent[node.left] == node else "Right" if parent[node.right] == node else "Root" for node in path[:-1]]
if node.left:
queue.append(node.left)
parent[node.left] = node
if node.right:
queue.append(node.right)
parent[node.right] = node
return []
```

In this implementation, we also convert the path of nodes to an array of strings that represent the direction from one node to the next. We use "Left", "Right", and "Root" to represent the directions, where "Left" means we move from the parent to the left child node, "Right" means we move from the parent to the right child node, and "Root" means we are at the root node. The last node in the path should always be the target node, so we exclude it from the array of strings by slicing it out.

Note that there can be multiple paths between two nodes in a binary tree, but the above algorithm will always find the shortest path.

## Step By Step Directions From A Binary Tree Node To Another Solution Code

`1`