# Reverse tree path using Queue

Given a tree and a node, the task is to reverse the path till the given Node and print the in-order traversal of the modified tree.

Examples:

```Input:
7
/   \
6     5
/ \   / \
4   3 2   1
Node = 4
Output: 7 6 3 4 2 5 1
The path from root to node 4 is 7 -> 6 -> 4
Reversing this path, the modified tree will be:
4
/   \
6     5
/ \   / \
7   3 2   1
whose in-order traversal is 7 6 3 4 2 5 1

Input:
7
/    \
6       5
/ \     / \
4  3     2  1
Node = 2
Output: 4 6 3 2 7 5 1
```

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

Approach:

• First store all the nodes on the given path in a queue.
• If the key is found then replace this node data with front of queue data and pop the front.
• Keep on performing this operation in the recursive way upto the root and the path will be reversed in the original tree.
• Now, print the in-order traversal of the modified tree.

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// A Binary Tree Node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// Function to reverse the tree path ` `queue<``int``> reverseTreePathUtil(Node* root, ``int` `data, ` `                               ``queue<``int``> q1) ` `{ ` `    ``queue<``int``> emptyQueue; ` ` `  `    ``// If root is null then return ` `    ``// an empty queue ` `    ``if` `(root == NULL) ` `        ``return` `emptyQueue; ` ` `  `    ``// If the node is found ` `    ``if` `(root->data == data) { ` ` `  `        ``// Replace it with the queue's front ` `        ``q1.push(root->data); ` `        ``root->data = q1.front(); ` `        ``q1.pop(); ` `        ``return` `q1; ` `    ``} ` ` `  `    ``// Push data into the queue for ` `    ``// storing data from start to end ` `    ``q1.push(root->data); ` ` `  `    ``// If the returned queue is empty then ` `    ``// it means that the left sub-tree doesn't ` `    ``// contain the required node ` `    ``queue<``int``> left = reverseTreePathUtil(root->left, ` `                                          ``data, q1); ` ` `  `    ``// If the returned queue is empty then ` `    ``// it means that the right sub-tree doesn't ` `    ``// contain the required node ` `    ``queue<``int``> right = reverseTreePathUtil(root->right, ` `                                           ``data, q1); ` ` `  `    ``// If the required node is found ` `    ``// in the right sub-tree ` `    ``if` `(!right.empty()) { ` ` `  `        ``// Replace with the queue's front ` `        ``root->data = right.front(); ` `        ``right.pop(); ` `        ``return` `right; ` `    ``} ` ` `  `    ``// If the required node is found ` `    ``// in the right sub-tree ` `    ``if` `(!left.empty()) { ` ` `  `        ``// Replace with the queue's front ` `        ``root->data = left.front(); ` `        ``left.pop(); ` `        ``return` `left; ` `    ``} ` ` `  `    ``// Return emptyQueue if path ` `    ``// is not found ` `    ``return` `emptyQueue; ` `} ` ` `  `// Function to call reverseTreePathUtil ` `// to reverse the tree path ` `void` `reverseTreePath(Node* root, ``int` `data) ` `{ ` `    ``queue<``int``> q1; ` `    ``// reverse tree path ` `    ``reverseTreePathUtil(root, data, q1); ` `} ` ` `  `// Function to print the in-order ` `// traversal of the tree ` `void` `inorder(Node* root) ` `{ ` `    ``if` `(root != NULL) { ` `        ``inorder(root->left); ` `        ``cout << root->data << ``" "``; ` `        ``inorder(root->right); ` `    ``} ` `} ` ` `  `// Utility function to create a new tree node ` `Node* newNode(``int` `data) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->data = data; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* root = newNode(7); ` `    ``root->left = newNode(6); ` `    ``root->right = newNode(5); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(3); ` `    ``root->right->left = newNode(2); ` `    ``root->right->right = newNode(1); ` ` `  `    ``int` `data = 4; ` ` `  `    ``// Function call to reverse the path ` `    ``reverseTreePath(root, data); ` ` `  `    ``// Print the in-order traversal ` `    ``// of the modified tree ` `    ``inorder(root); ` ` `  `    ``return` `0; ` `} `

Output:

```7 6 3 4 2 5 1
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.