Reverse tree path

Difficulty Level : Hard
Last Updated : 03 Feb, 2021

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

Let’s understand the code:

C++

// CPP program to Reverse Tree path
#include <bits/stdc++.h>
using namespace std;
 
// A Binary Tree Node
struct 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 perticular 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 path
void 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);
}
 
// INORDER
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 program to test above functions
int 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

// Java program to Reverse Tree path
import java.util.*;
class solution
{
   
// A Binary Tree Node
static class Node {
    int data;
     Node left, right;
};
 
//class for int values
static 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 perticular 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);
}
   
// INORDER
static 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 functions
public 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

# Python3 program to Reverse Tree path
 
# A Binary Tree Node
class 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 perticular 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 path
def 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);
 
# INORDER
def inorder(root):
    if (root != None):
        inorder(root.left);
        print(root.data, end = ' ')
        inorder(root.right);
     
# Utility function to create a new tree node
def newNode(data):
    temp = Node(data)
    return temp;
 
# Driver code
if __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#

// C# program to Reverse Tree path
using System;
using System.Collections.Generic;
 
class GFG
{
 
// A Binary Tree Node
public class Node
{
    public int data;
    public Node left, right;
}
 
//class for int values
public 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 perticular 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 path
public 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);
}
 
// INORDER
public 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 node
public static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}
 
// Driver Code
public 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

Output

7 6 3 4 2 5 1

Another Approach:

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++

// 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 tree
void inorder(Node* temp)
{
    if (temp == NULL)
        return;
 
    inorder(temp->left);
    cout << temp->data << " ";
    inorder(temp->right);
}
 
// Utility function to track
// root to leaf paths
void 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 oath 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 path
void 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 Code
int 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

// Java program for the above approach
import 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 tree
static 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 paths
static 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 oath 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 path
static 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 Code
public 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.

Output

7 6 3 4 2 5 1

Time Complexity: O(N)

Space Complexity: O(N)

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

Related Articles

C++

Java

Python3

C#

Another Approach:

C++

Java