Reverse tree path - GeeksforGeeks

02 May, 2022
Given a tree and node data, the task to reverse the path to that particular Node.
Examples: 
Input: 
            7
         /    \
        6       5
       / \     / \
      4  3     2  1    
Data = 4 
Output: Inorder of tree
7 6 3 4 2 5 1


Input:
            7
         /    \
        6       5
       / \     / \
      4  3     2  1   
Data = 2 
Output : Inorder of tree
4 6 3 2 7 5 1
The idea is to use a map to store path level wise. 
Find the Node path as well as store it in the map 
the path is  
Replace the position with the map nextPos index value  
increment the nextpos index and replace the next value  
increment the nextpos index and replace the next value  
Let’s understand the code:
C++
Java
Python3
C#
Javascript
// C++ program to Reverse Tree path#include <bits/stdc++.h>using namespace std; // A Binary Tree Nodestruct Node {    int data;    struct Node *left, *right;}; // 'data' is input. We need to reverse path from// root to data.// 'level' is current level.// 'temp' that stores path nodes.// 'nextpos' used to pick next item for reversing.Node* reverseTreePathUtil(Node* root, int data,       map<int, int>& temp, int level, int& nextpos){    // return NULL if root NULL    if (root == NULL)        return NULL;     // Final condition    // if the node is found then    if (data == root->data) {         // store the value in it's level        temp[level] = root->data;         // change the root value with the current        // next element of the map        root->data = temp[nextpos];         // increment in k for the next element        nextpos++;        return root;    }     // store the data in particular level    temp[level] = root->data;     // We go to right only when left does not    // contain given data. This way we make sure    // that correct path node is stored in temp[]    Node *left, *right;    left = reverseTreePathUtil(root->left, data, temp,                                  level + 1, nextpos);    if (left == NULL)        right = reverseTreePathUtil(root->right, data,                            temp, level + 1, nextpos);     // If current node is part of the path,    // then do reversing.    if (left || right) {        root->data = temp[nextpos];        nextpos++;        return (left ? left : right);    }     // return NULL if not element found    return NULL;} // Reverse Tree pathvoid reverseTreePath(Node* root, int data){    // store per level data    map<int, int> temp;     // it is for replacing the data    int nextpos = 0;     // reverse tree path    reverseTreePathUtil(root, data, temp, 0, nextpos);} // INORDERvoid inorder(Node* root){    if (root != NULL) {        inorder(root->left);        cout << root->data << " ";        inorder(root->right);    }} // Utility function to create a new tree nodeNode* newNode(int data){    Node* temp = new Node;    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // Driver program to test above functionsint main(){    // Let us create binary tree shown in above diagram    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);     /*     7         /    \        6       5       / \     / \      4  3     2  1          */     int data = 4;     // Reverse Tree Path    reverseTreePath(root, data);     // Traverse inorder    inorder(root);    return 0;}
// Java program to Reverse Tree pathimport java.util.*;class solution{   // A Binary Tree Nodestatic class Node {    int data;     Node left, right;}; //class for int valuesstatic class INT {    int data;};   // 'data' is input. We need to reverse path from// root to data.// 'level' is current level.// 'temp' that stores path nodes.// 'nextpos' used to pick next item for reversing. static Node reverseTreePathUtil(Node root, int data,       Map<Integer, Integer> temp, int level, INT nextpos){    // return null if root null    if (root == null)        return null;       // Final condition    // if the node is found then    if (data == root.data) {           // store the value in it's level        temp.put(level,root.data);           // change the root value with the current         // next element of the map        root.data = temp.get(nextpos.data);           // increment in k for the next element        nextpos.data++;        return root;    }       // store the data in particular level    temp.put(level,root.data);       // We go to right only when left does not     // contain given data. This way we make sure    // that correct path node is stored in temp[]    Node left, right=null;    left = reverseTreePathUtil(root.left, data, temp,                                   level + 1, nextpos);    if (left == null)        right = reverseTreePathUtil(root.right, data,                             temp, level + 1, nextpos);       // If current node is part of the path,    // then do reversing.    if (left!=null || right!=null) {        root.data = temp.get(nextpos.data);        nextpos.data++;        return (left!=null ? left : right);    }       // return null if not element found    return null;}   // Reverse Tree path static void reverseTreePath(Node root, int data){    // store per level data    Map< Integer, Integer> temp= new HashMap< Integer, Integer>();       // it is for replacing the data    INT nextpos=new INT();    nextpos.data = 0;       // reverse tree path    reverseTreePathUtil(root, data, temp, 0, nextpos);}   // INORDERstatic void inorder(Node root){    if (root != null) {        inorder(root.left);        System.out.print( root.data + " ");        inorder(root.right);    }}   // Utility function to create a new tree node static Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;}   // Driver program to test above functionspublic static void main(String args[]){    // Let us create binary tree shown in above diagram    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);         /*   7         /    \        6       5       / \     / \      4  3     2  1         */       int data = 4;       // Reverse Tree Path    reverseTreePath(root, data);       // Traverse inorder    inorder(root);}}//contributed by Arnab Kundu
# Python3 program to Reverse Tree path # A Binary Tree Nodeclass Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # 'data' is input. We need to reverse path from# root to data.# 'level' is current level.# 'temp' that stores path nodes.# 'nextpos' used to pick next item for reversing.def reverseTreePathUtil(root, data,temp, level, nextpos):     # return None if root None    if (root == None):        return None, temp, nextpos;     # Final condition    # if the node is found then    if (data == root.data):         # store the value in it's level        temp[level] = root.data;         # change the root value with the current        # next element of the map        root.data = temp[nextpos];         # increment in k for the next element        nextpos += 1        return root, temp, nextpos;         # store the data in particular level    temp[level] = root.data;     # We go to right only when left does not    # contain given data. This way we make sure    # that correct path node is stored in temp[]    right = None    left, temp, nextpos = reverseTreePathUtil(root.left, data, temp,                                  level + 1, nextpos);    if (left == None):        right, temp, nextpos = reverseTreePathUtil(root.right, data,                            temp, level + 1, nextpos);     # If current node is part of the path,    # then do reversing.    if (left or right):        root.data = temp[nextpos];        nextpos += 1        return (left if left != None else right), temp, nextpos;         # return None if not element found    return None, temp, nextpos; # Reverse Tree pathdef reverseTreePath(root, data):     # store per level data    temp = dict()     # it is for replacing the data    nextpos = 0;     # reverse tree path    reverseTreePathUtil(root, data, temp, 0, nextpos); # INORDERdef inorder(root):    if (root != None):        inorder(root.left);        print(root.data, end = ' ')        inorder(root.right);     # Utility function to create a new tree nodedef newNode(data):    temp = Node(data)    return temp; # Driver codeif __name__=='__main__':     # Let us create binary tree shown in above diagram    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);     '''     7         /    \        6       5       / \     / \      4  3     2  1          '''     data = 4;     # Reverse Tree Path    reverseTreePath(root, data);     # Traverse inorder    inorder(root);     # This code is contributed by rutvik_56.
// C# program to Reverse Tree pathusing System;using System.Collections.Generic; class GFG{ // A Binary Tree Nodepublic class Node{    public int data;    public Node left, right;} //class for int valuespublic class INT{    public int data;} // 'data' is input. We need to reverse// path from root to data.// 'level' is current level.// 'temp' that stores path nodes.// 'nextpos' used to pick next item for reversing.public static Node reverseTreePathUtil(Node root, int data,                                       IDictionary<int, int> temp,                                       int level, INT nextpos){    // return null if root null    if (root == null)    {        return null;    }     // Final condition    // if the node is found then    if (data == root.data)    {         // store the value in it's level        temp[level] = root.data;         // change the root value with the        // current next element of the map        root.data = temp[nextpos.data];         // increment in k for the next element        nextpos.data++;        return root;    }     // store the data in particular level    temp[level] = root.data;     // We go to right only when left does not    // contain given data. This way we make sure    // that correct path node is stored in temp[]    Node left, right = null;    left = reverseTreePathUtil(root.left, data, temp,                               level + 1, nextpos);    if (left == null)    {        right = reverseTreePathUtil(root.right, data, temp,                                    level + 1, nextpos);    }     // If current node is part of the path,    // then do reversing.    if (left != null || right != null)    {        root.data = temp[nextpos.data];        nextpos.data++;        return (left != null ? left : right);    }     // return null if not element found    return null;} // Reverse Tree pathpublic static void reverseTreePath(Node root,                                   int data){    // store per level data    IDictionary<int,                int> temp = new Dictionary<int,                                           int>();     // it is for replacing the data    INT nextpos = new INT();    nextpos.data = 0;     // reverse tree path    reverseTreePathUtil(root, data,                        temp, 0, nextpos);} // INORDERpublic static void inorder(Node root){    if (root != null)    {        inorder(root.left);        Console.Write(root.data + " ");        inorder(root.right);    }} // Utility function to create// a new tree nodepublic static Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // Driver Codepublic static void Main(string[] args){    // Let us create binary tree    // shown in above diagram    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);     /* 7        / \        6     5    / \     / \    4 3     2 1         */     int data = 4;     // Reverse Tree Path    reverseTreePath(root, data);     // Traverse inorder    inorder(root);}} // This code is contributed by Shrikant13
<script> // Javascript program to Reverse Tree path // A Binary Tree Nodeclass Node{    constructor()    {        this.data = 0;        this.left = null;        this.right = null;    }} // Class for int valuesclass INT{    constructor()    {        this.data = 0;    }} // 'data' is input. We need to reverse// path from root to data.// 'level' is current level.// 'temp' that stores path nodes.// 'nextpos' used to pick next item for reversing.function reverseTreePathUtil(root, data,  temp,                             level, nextpos){         // Return null if root null    if (root == null)    {        return null;    }     // Final condition    // if the node is found then    if (data == root.data)    {                 // Store the value in it's level        temp[level] = root.data;         // Change the root value with the        // current next element of the map        root.data = temp[nextpos.data];         // Increment in k for the next element        nextpos.data++;        return root;    }     // Store the data in particular level    temp[level] = root.data;     // We go to right only when left does not    // contain given data. This way we make sure    // that correct path node is stored in temp[]    var left, right = null;    left = reverseTreePathUtil(root.left, data, temp,                               level + 1, nextpos);    if (left == null)    {        right = reverseTreePathUtil(root.right, data, temp,                                    level + 1, nextpos);    }     // If current node is part of the path,    // then do reversing.    if (left != null || right != null)    {        root.data = temp[nextpos.data];        nextpos.data++;        return (left != null ? left : right);    }     // Return null if not element found    return null;} // Reverse Tree pathfunction reverseTreePath(root, data){         // Store per level data    var temp = new Map();     // It is for replacing the data    var nextpos = new INT();    nextpos.data = 0;     // Reverse tree path    reverseTreePathUtil(root, data,                        temp, 0, nextpos);} // INORDERfunction inorder(root){    if (root != null)    {        inorder(root.left);        document.write(root.data + " ");        inorder(root.right);    }} // Utility function to create// a new tree nodefunction newNode(data){    var temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // Driver Code // Let us create binary tree// shown in above diagramvar 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);/*   7    / \   6    5  / \  / \ 4   3 2  1         */var data = 4; // Reverse Tree PathreverseTreePath(root, data); // Traverse inorderinorder(root); // This code is contributed by rrrtnx </script>
7 6 3 4 2 5 1 
Use the concept of printing all the root-to-leaf paths. The idea is to keep a track of the path from the root to that particular node upto which the path is to be reversed and once we get that particular node we simply reverse the data of those nodes.Here we will not only try to track all the root the leaf paths but also check for the node up to which we need to reverse the path.
Use a vector to store every path.
Once we get the node up to which the path needs to be reversed we use a simple algorithm to reverse the data of the nodes found in the followed path that is store in the vector.
Implementation of the above approach given below:
C++
Java
Python3
C#
Javascript
// CPP program for the above approach#include <bits/stdc++.h>using namespace std;#define nl "\n"class Node {public:    int data;    Node* left;    Node* right;    Node(int value) { data = value; }}; // Function to print inorder// traversal of the treevoid inorder(Node* temp){    if (temp == NULL)        return;     inorder(temp->left);    cout << temp->data << " ";    inorder(temp->right);} // Utility function to track// root to leaf pathsvoid reverseTreePathUtil(Node* root, vector<Node*> path,                         int pathLen, int key){    // Check if root is null then return    if (root == NULL)        return;       // Store the node in path array    path[pathLen] = root;    pathLen++;     // Check if we find the node upto    // which path needs to be    // reversed    if (root->data == key) {               // Current path array contains        // the path which needs        // to be reversed        int i = 0, j = pathLen - 1;               // Swap the data of two nodes        while (i < j) {            int temp = path[i]->data;            path[i]->data = path[j]->data;            path[j]->data = temp;            i++;            j--;        }    }       // Check if the node is a    // leaf node then return    if (!root->left and !root->right)        return;         // Call utility function for    // left and right subtree    // recursively    reverseTreePathUtil(root->left, path,                             pathLen, key);    reverseTreePathUtil(root->right, path,                              pathLen, key);} // Function to reverse tree pathvoid reverseTreePath(Node* root, int key){    if (root == NULL)        return;       // Initialize a vector to store paths    vector<Node*> path(50, NULL);    reverseTreePathUtil(root, path, 0, key);} // Driver Codeint main(){    Node* root = new Node(7);    root->left = new Node(6);    root->right = new Node(5);    root->left->left = new Node(4);    root->left->right = new Node(3);    root->right->left = new Node(2);    root->right->right = new Node(1);     /*     7         /    \        6       5       / \     / \      4  3     2  1          */     int key = 4;    reverseTreePath(root, key);    inorder(root);    return 0;}
// Java program for the above approachimport java.util.*;class GFG{ static class Node {    int data;    Node left;    Node right;    Node(int value)    { this.data = value; }}; // Function to print inorder// traversal of the treestatic void inorder(Node temp){    if (temp == null)        return;     inorder(temp.left);    System.out.print(temp.data+" ");    inorder(temp.right);} // Utility function to track// root to leaf pathsstatic void reverseTreePathUtil(Node root, ArrayList<Node> path,                         int pathLen, int key){       // Check if root is null then return    if (root == null)        return;       // Store the node in path array    path.set(pathLen, root);    pathLen++;     // Check if we find the node upto    // which path needs to be    // reversed    if (root.data == key) {               // Current path array contains        // the path which needs        // to be reversed        int i = 0, j = pathLen - 1;               // Swap the data of two nodes        while (i < j)        {            int temp = path.get(i).data;            path.get(i).data = path.get(j).data;            path.get(j).data = temp;            i++;            j--;        }    }       // Check if the node is a    // leaf node then return    if (root.left == null && root.right == null)        return;         // Call utility function for    // left and right subtree    // recursively    reverseTreePathUtil(root.left, path,                             pathLen, key);    reverseTreePathUtil(root.right, path,                              pathLen, key);} // Function to reverse tree pathstatic void reverseTreePath(Node root, int key){    if (root == null)        return;       // Initialize a vector to store paths    ArrayList<Node> path = new ArrayList<Node>();    for(int i = 0; i < 50; i++)    {        path.add(null);    }    reverseTreePathUtil(root, path, 0, key);} // Driver Codepublic static void main(String []args){    Node root = new Node(7);    root.left = new Node(6);    root.right = new Node(5);    root.left.left = new Node(4);    root.left.right = new Node(3);    root.right.left = new Node(2);    root.right.right = new Node(1);     /*     7         /    \        6       5       / \     / \      4  3     2  1          */     int key = 4;    reverseTreePath(root, key);    inorder(root);}} // This code is contributed by pratham76.
# Python program for the above approachclass Node:    def __init__(self, data):        self.data = data;        self.left = None;        self.right = None; # Function to print inorder# traversal of the treedef inorder(temp):    if (temp == None):        return;     inorder(temp.left);    print(temp.data, end=" ");    inorder(temp.right); # Utility function to track# root to leaf pathsdef reverseTreePathUtil(root, path, pathLen, key):     # Check if root is None then return    if (root == None):        return;     # Store the Node in path array    path[pathLen] = root;    pathLen+=1;     # Check if we find the Node upto    # which path needs to be    # reversed    if (root.data == key):         # Current path array contains        # the path which needs        # to be reversed        i = 0;        j = pathLen - 1;         # Swap the data of two Nodes        while (i < j):            temp = path[i].data;            path[i].data = path[j].data;            path[j].data = temp;            i += 1;            j -= 1;     # Check if the Node is a    # leaf Node then return    if (root.left == None and root.right == None):        return;     # Call utility function for    # left and right subtree    # recursively    reverseTreePathUtil(root.left, path, pathLen, key);    reverseTreePathUtil(root.right, path, pathLen, key); # Function to reverse tree pathdef reverseTreePath(root, key):    if (root == None):        return;     # Initialize a vector to store paths    path = [None for i in range(50)];         reverseTreePathUtil(root, path, 0, key); # Driver Codeif __name__ == '__main__':    root = Node(7);    root.left = Node(6);    root.right = Node(5);    root.left.left = Node(4);    root.left.right = Node(3);    root.right.left = Node(2);    root.right.right = Node(1);     '''     * 7 / \ 6 5 / \ / \ 4 3 2 1     '''     key = 4;    reverseTreePath(root, key);    inorder(root); # This code is contributed by umadevi9616
// C# program for the above approachusing System;using System.Collections.Generic; public class GFG{ public class Node {   public int data;   public Node left;   public Node right;   public Node(int value)    { this.data = value; }}; // Function to print inorder// traversal of the treestatic void inorder(Node temp){    if (temp == null)        return;     inorder(temp.left);    Console.Write(temp.data+" ");    inorder(temp.right);} // Utility function to track// root to leaf pathsstatic void reverseTreePathUtil(Node root, List<Node> path,                         int pathLen, int key){       // Check if root is null then return    if (root == null)        return;       // Store the node in path array    path[pathLen]= root;    pathLen++;     // Check if we find the node upto    // which path needs to be    // reversed    if (root.data == key) {               // Current path array contains        // the path which needs        // to be reversed        int i = 0, j = pathLen - 1;               // Swap the data of two nodes        while (i < j)        {            int temp = path[i].data;            path[i].data = path[j].data;            path[j].data = temp;            i++;            j--;        }    }       // Check if the node is a    // leaf node then return    if (root.left == null && root.right == null)        return;         // Call utility function for    // left and right subtree    // recursively    reverseTreePathUtil(root.left, path,                             pathLen, key);    reverseTreePathUtil(root.right, path,                              pathLen, key);} // Function to reverse tree pathstatic void reverseTreePath(Node root, int key){    if (root == null)        return;       // Initialize a vector to store paths    List<Node> path = new List<Node>();    for(int i = 0; i < 50; i++)    {        path.Add(null);    }    reverseTreePathUtil(root, path, 0, key);} // Driver Codepublic static void Main(String []args){    Node root = new Node(7);    root.left = new Node(6);    root.right = new Node(5);    root.left.left = new Node(4);    root.left.right = new Node(3);    root.right.left = new Node(2);    root.right.right = new Node(1);     /*     7         /    \        6       5       / \     / \      4  3     2  1          */     int key = 4;    reverseTreePath(root, key);    inorder(root);}} // This code is contributed by umadevi9616
<script> // JavaScript program for the above approach class Node{    constructor(value)    {        this.data=value;        this.left=this.right=null;    }} // Function to print inorder// traversal of the tree   function inorder(temp){    if (temp == null)        return;      inorder(temp.left);    document.write(temp.data+" ");    inorder(temp.right);} // Utility function to track// root to leaf pathsfunction reverseTreePathUtil(root,path,pathLen,key){    // Check if root is null then return    if (root == null)        return;        // Store the node in path array    path[pathLen] = root;    pathLen++;      // Check if we find the node upto    // which path needs to be    // reversed    if (root.data == key) {                // Current path array contains        // the path which needs        // to be reversed        let i = 0, j = pathLen - 1;                // Swap the data of two nodes        while (i < j)        {            let temp = path[i].data;            path[i].data = path[j].data;            path[j].data = temp;            i++;            j--;        }    }        // Check if the node is a    // leaf node then return    if (root.left == null && root.right == null)        return;          // Call utility function for    // left and right subtree    // recursively    reverseTreePathUtil(root.left, path,                             pathLen, key);    reverseTreePathUtil(root.right, path,                              pathLen, key);} // Function to reverse tree pathfunction reverseTreePath(root,key){    if (root == null)        return;        // Initialize a vector to store paths    let path = [];    for(let i = 0; i < 50; i++)    {        path.push(null);    }    reverseTreePathUtil(root, path, 0, key);} // Driver Codelet root = new Node(7);root.left = new Node(6);root.right = new Node(5);root.left.left = new Node(4);root.left.right = new Node(3);root.right.left = new Node(2);root.right.right = new Node(1); /*         7         /    \        6       5       / \     / \      4  3     2  1          */ let key = 4;reverseTreePath(root, key);inorder(root); // This code is contributed by avanitrachhadiya2155 </script>
7 6 3 4 2 5 1 
Time Complexity: O(N)
Space Complexity: O(N)
andrew1234
shrikanth13
sameershrivastava46
rutvik_56
pratham76
sooda367
rrrtnx
avanitrachhadiya2155
umadevi9616
sumitgumber28
simmytarika5
cpp-map
Reverse
Tree
Tree
Reverse
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not
Construct Tree from given Inorder and Preorder traversals
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Expression Tree
Deletion in a Binary Tree