# Print path from root to a given node in a binary tree

Given a binary tree with distinct nodes(no two nodes have the same data values). The problem is to print the path from root to a given node x. If node x is not present then print “No Path”.

Examples:

Input :          1
/   \
2     3
/  \   /  \
4    5  6   7
x = 5
Output : 1->2->5

Approach: Create a recursive function that traverses the different path in the binary tree to find the required node x. If node x is present then it returns true and accumulates the path nodes in some array arr[]. Else it returns false.

Following are the cases during the traversal:

1. If root = NULL, return false.
2. push the root’s data into arr[].
3. if root’s data = x, return true.
4. if node x is present in root’s left or right subtree, return true.
5. Else remove root’s data value from arr[] and return false.

This recursive function can be accessed from other function to check whether node x is present or not and if it is present, then the path nodes can be accessed from arr[]. You can define arr[] globally or pass its reference to the recursive function.

Implementation:

## C++

 `// C++ implementation to print the path from root``// to a given node in a binary tree``#include ``using` `namespace` `std;` `// structure of a node of binary tree``struct` `Node``{``    ``int` `data;``    ``Node *left, *right;``};` `/* Helper function that allocates a new node with the``   ``given data and NULL left and right pointers. */``struct` `Node* getNode(``int` `data)``{``    ``struct` `Node *newNode = ``new` `Node;``    ``newNode->data = data;``    ``newNode->left = newNode->right = NULL;``    ``return` `newNode;``}` `// Returns true if there is a path from root``// to the given node. It also populates ``// 'arr' with the given path``bool` `hasPath(Node *root, vector<``int``>& arr, ``int` `x)``{``    ``// if root is NULL``    ``// there is no path``    ``if` `(!root)``        ``return` `false``;``    ` `    ``// push the node's value in 'arr'``    ``arr.push_back(root->data);    ``    ` `    ``// if it is the required node``    ``// return true``    ``if` `(root->data == x)    ``        ``return` `true``;``    ` `    ``// else check whether the required node lies``    ``// in the left subtree or right subtree of ``    ``// the current node``    ``if` `(hasPath(root->left, arr, x) ||``        ``hasPath(root->right, arr, x))``        ``return` `true``;``    ` `    ``// required node does not lie either in the ``    ``// left or right subtree of the current node``    ``// Thus, remove current node's value from ``    ``// 'arr'and then return false    ``    ``arr.pop_back();``    ``return` `false``;            ``}` `// function to print the path from root to the``// given node if the node lies in the binary tree``void` `printPath(Node *root, ``int` `x)``{``    ``// vector to store the path``    ``vector<``int``> arr;``    ` `    ``// if required node 'x' is present``    ``// then print the path``    ``if` `(hasPath(root, arr, x))``    ``{``        ``for` `(``int` `i=0; i"``;``        ``cout << arr[arr.size() - 1];    ``    ``}``    ` `    ``// 'x' is not present in the binary tree ``    ``else``        ``cout << ``"No Path"``;``}` `// Driver program to test above``int` `main()``{``    ``// binary tree formation``    ``struct` `Node *root = getNode(1);``    ``root->left = getNode(2);``    ``root->right = getNode(3);``    ``root->left->left = getNode(4);``    ``root->left->right = getNode(5);``    ``root->right->left = getNode(6);``    ``root->right->right = getNode(7);``        ` `    ``int` `x = 5;``    ``printPath(root, x);``    ``return` `0;``} `

## Java

 `// Java implementation to print the path from root ``// to a given node in a binary tree ``import` `java.util.ArrayList;``public` `class` `PrintPath {` `    ``// Returns true if there is a path from root ``    ``// to the given node. It also populates  ``    ``// 'arr' with the given path ``    ``public` `static` `boolean` `hasPath(Node root, ArrayList arr, ``int` `x) ``    ``{ ``        ``// if root is NULL ``        ``// there is no path ``        ``if` `(root==``null``) ``            ``return` `false``; ``      ` `        ``// push the node's value in 'arr' ``        ``arr.add(root.data);     ``      ` `        ``// if it is the required node ``        ``// return true ``        ``if` `(root.data == x)     ``            ``return` `true``; ``      ` `        ``// else check whether the required node lies ``        ``// in the left subtree or right subtree of  ``        ``// the current node ``        ``if` `(hasPath(root.left, arr, x) || ``            ``hasPath(root.right, arr, x)) ``            ``return` `true``; ``      ` `        ``// required node does not lie either in the  ``        ``// left or right subtree of the current node ``        ``// Thus, remove current node's value from  ``        ``// 'arr'and then return false     ``        ``arr.remove(arr.size()-``1``); ``        ``return` `false``;             ``    ``} ` `    ``// function to print the path from root to the ``    ``// given node if the node lies in the binary tree ``    ``public` `static` `void` `printPath(Node root, ``int` `x) ``    ``{ ``        ``// ArrayList to store the path ``        ``ArrayList arr=``new` `ArrayList<>();``    ` `        ``// if required node 'x' is present ``        ``// then print the path ``        ``if` `(hasPath(root, arr, x)) ``        ``{ ``            ``for` `(``int` `i=``0``; i"``);``            ``System.out.print(arr.get(arr.size() - ``1``));    ``        ``} ``      ` `        ``// 'x' is not present in the binary tree  ``        ``else``            ``System.out.print(``"No Path"``); ``    ``} ` `    ``public` `static` `void` `main(String args[]) {``        ``Node root=``new` `Node(``1``);``        ``root.left = ``new` `Node(``2``); ``        ``root.right = ``new` `Node(``3``); ``        ``root.left.left = ``new` `Node(``4``); ``        ``root.left.right = ``new` `Node(``5``); ``        ``root.right.left = ``new` `Node(``6``); ``        ``root.right.right = ``new` `Node(``7``); ``        ``int` `x=``5``;``        ``printPath(root, x);``    ``}``}` `// A node of binary tree ``class` `Node ``{ ``    ``int` `data; ``    ``Node left, right; ``    ``Node(``int` `data)``    ``{``        ``this``.data=data;``        ``left=right=``null``;``    ``}``}; ``//This code is contributed by Gaurav Tiwari`

## Python3

 `# Python3 implementation to print the path from ``# root to a given node in a binary tree ` `# Helper Class that allocates a new node ``# with the given data and None left and ``# right pointers. ``class` `getNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data ``        ``self``.left ``=` `self``.right ``=` `None` `# Returns true if there is a path from ``# root to the given node. It also ``# populates 'arr' with the given path ``def` `hasPath(root, arr, x):``    ` `    ``# if root is None there is no path ``    ``if` `(``not` `root):``        ``return` `False``    ` `    ``# push the node's value in 'arr' ``    ``arr.append(root.data)     ``    ` `    ``# if it is the required node ``    ``# return true ``    ``if` `(root.data ``=``=` `x):     ``        ``return` `True``    ` `    ``# else check whether the required node ``    ``# lies in the left subtree or right ``    ``# subtree of the current node ``    ``if` `(hasPath(root.left, arr, x) ``or``        ``hasPath(root.right, arr, x)): ``        ``return` `True``    ` `    ``# required node does not lie either in ``    ``# the left or right subtree of the current ``    ``# node. Thus, remove current node's value  ``    ``# from 'arr'and then return false     ``    ``arr.pop(``-``1``) ``    ``return` `False` `# function to print the path from root to ``# the given node if the node lies in``# the binary tree ``def` `printPath(root, x):``    ` `    ``# vector to store the path ``    ``arr ``=` `[] ``    ` `    ``# if required node 'x' is present ``    ``# then print the path ``    ``if` `(hasPath(root, arr, x)):``        ``for` `i ``in` `range``(``len``(arr) ``-` `1``):``            ``print``(arr[i], end ``=` `"->"``) ``        ``print``(arr[``len``(arr) ``-` `1``])``    ` `    ``# 'x' is not present in the ``    ``# binary tree ``    ``else``:``        ``print``(``"No Path"``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# binary tree formation ``    ``root ``=` `getNode(``1``) ``    ``root.left ``=` `getNode(``2``) ``    ``root.right ``=` `getNode(``3``) ``    ``root.left.left ``=` `getNode(``4``) ``    ``root.left.right ``=` `getNode(``5``) ``    ``root.right.left ``=` `getNode(``6``) ``    ``root.right.right ``=` `getNode(``7``) ``        ` `    ``x ``=` `5``    ``printPath(root, x)``    ` `# This code is contributed by PranchalK`

## C#

 `// C# implementation to print the path from root ``// to a given node in a binary tree ``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `PrintPath ``{``    ` `// A node of binary tree ``public` `class` `Node ``{ ``    ``public` `int` `data; ``    ``public` `Node left, right; ``    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `    ``// Returns true if there is a path from root ``    ``// to the given node. It also populates ``    ``// 'arr' with the given path ``    ``public` `static` `Boolean hasPath(Node root,``                        ``List<``int``> arr, ``int` `x) ``    ``{ ``        ``// if root is NULL ``        ``// there is no path ``        ``if` `(root == ``null``) ``            ``return` `false``; ``        ` `        ``// push the node's value in 'arr' ``        ``arr.Add(root.data);     ``        ` `        ``// if it is the required node ``        ``// return true ``        ``if` `(root.data == x)     ``            ``return` `true``; ``        ` `        ``// else check whether the required node lies ``        ``// in the left subtree or right subtree of ``        ``// the current node ``        ``if` `(hasPath(root.left, arr, x) || ``            ``hasPath(root.right, arr, x)) ``            ``return` `true``; ``        ` `        ``// required node does not lie either in the ``        ``// left or right subtree of the current node ``        ``// Thus, remove current node's value from ``        ``// 'arr'and then return false     ``        ``arr.RemoveAt(arr.Count - 1); ``        ``return` `false``;             ``    ``} ` `    ``// function to print the path from root to the ``    ``// given node if the node lies in the binary tree ``    ``public` `static` `void` `printPath(Node root, ``int` `x) ``    ``{ ``        ``// List to store the path ``        ``List<``int``> arr = ``new` `List<``int``>();``    ` `        ``// if required node 'x' is present ``        ``// then print the path ``        ``if` `(hasPath(root, arr, x)) ``        ``{ ``            ``for` `(``int` `i = 0; i < arr.Count - 1; i++)     ``                ``Console.Write(arr[i]+``"->"``);``            ``Console.Write(arr[arr.Count - 1]); ``        ``} ``        ` `        ``// 'x' is not present in the binary tree ``        ``else``            ``Console.Write(``"No Path"``); ``    ``} ` `    ``// Driver code``    ``public` `static` `void` `Main(String []args) ``    ``{``        ` `        ``Node root = ``new` `Node(1);``        ``root.left = ``new` `Node(2); ``        ``root.right = ``new` `Node(3); ``        ``root.left.left = ``new` `Node(4); ``        ``root.left.right = ``new` `Node(5); ``        ``root.right.left = ``new` `Node(6); ``        ``root.right.right = ``new` `Node(7); ``        ``int` `x=5;``        ` `        ``printPath(root, x);``    ``}``}` `// This code is contributed by Arnab Kundu`

## Javascript

 ``

Output
```1->2->5

```

Time complexity: O(n) where n is the number of nodes in the binary tree.
Auxiliary Space: O(H) where H = height of the binary tree.

### Another Approach(Iterative Approach Using Stack):

Follow the below steps to solve the above problem:

1) Start at the root node and push it onto a stack.
2) Create a separate stack to store the path from the root to the current node.
3) While the stack is not empty, do the following:
a) Pop the top node from the stack and add it to the path stack.
b) If the current node is the target node, print the nodes in the path stack to get the path from the root to the target node.
c) Push the right child of the current node onto the stack if it exists.
d) Push the left child of the current node onto the stack if it exists.

Below is the implementation of above approach:

## C++

 `// C++ Program to print the path from root``// to a given node in binary tree``#include ``using` `namespace` `std;` `// Structure of binary tree node``struct` `Node {``    ``int` `data;``    ``Node* left;``    ``Node* right;` `    ``Node(``int` `value){``        ``data = value;``        ``left = right = NULL;``    ``}``};` `// function which will print the path``void` `printPath(Node* root, ``int` `target) {``    ``vector<``int``> path;``    ``stack nodeStack;``    ``Node* curr = root;``    ``Node* prev = NULL;` `    ``while` `(curr || !nodeStack.empty()){``        ``while` `(curr){``            ``nodeStack.push(curr);``            ``path.push_back(curr->data);``            ``curr = curr->left;``        ``}``        ` `        ``curr = nodeStack.top();``        ` `        ``if` `(curr->right && curr->right != prev){``            ``curr = curr->right;``        ``}``else``{``            ``if` `(curr->data == target){``                ``for``(``int` `i = 0; i"``;``                ``cout<left = ``new` `Node(2);``    ``root->right = ``new` `Node(3);``    ``root->left->left = ``new` `Node(4);``    ``root->left->right = ``new` `Node(5);``    ``root->right->left = ``new` `Node(6);``    ``root->right->right = ``new` `Node(7);` `    ``int` `target = 5;``    ``printPath(root, target);``    ``return` `0;``}``// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)`

## Java

 `import` `java.util.Stack;``import` `java.util.Vector;` `// Structure of binary tree node``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``int` `value) {``        ``data = value;``        ``left = right = ``null``;``    ``}``}` `public` `class` `BinaryTreePath {``    ``// function which will print the path``    ``static` `void` `printPath(Node root, ``int` `target) {``        ``Vector path = ``new` `Vector<>();``        ``Stack nodeStack = ``new` `Stack<>();``        ``Node curr = root;``        ``Node prev = ``null``;` `        ``while` `(curr != ``null` `|| !nodeStack.isEmpty()) {``            ``while` `(curr != ``null``) {``                ``nodeStack.push(curr);``                ``path.add(curr.data);``                ``curr = curr.left;``            ``}` `            ``curr = nodeStack.pop();` `            ``if` `(curr.right != ``null` `&& curr.right != prev) {``                ``curr = curr.right;``            ``} ``else` `{``                ``if` `(curr.data == target) {``                    ``for` `(``int` `i = ``0``; i < path.size() - ``1``; i++)``                        ``System.out.print(path.get(i) + ``"->"``);``                    ``System.out.println(path.get(path.size() - ``1``));``                    ``return``;``                ``}``                ``path.remove(path.size() - ``1``);``                ``prev = curr;``                ``curr = ``null``;``            ``}``        ``}``        ``System.out.println(``"No Path"``);``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args) {``        ``// Create a binary tree``        ``Node root = ``new` `Node(``1``);``        ``root.left = ``new` `Node(``2``);``        ``root.right = ``new` `Node(``3``);``        ``root.left.left = ``new` `Node(``4``);``        ``root.left.right = ``new` `Node(``5``);``        ``root.right.left = ``new` `Node(``6``);``        ``root.right.right = ``new` `Node(``7``);` `        ``int` `target = ``5``;``        ``printPath(root, target);``    ``}``}`

## Python3

 `class` `TreeNode:``    ``def` `__init__(``self``, value):``        ``self``.data ``=` `value``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `def` `print_path(root, target):``    ``path ``=` `[]``    ``node_stack ``=` `[]``    ``curr ``=` `root``    ``prev ``=` `None` `    ``while` `curr ``or` `node_stack:``        ``while` `curr:``            ``node_stack.append(curr)``            ``path.append(curr.data)``            ``curr ``=` `curr.left` `        ``curr ``=` `node_stack[``-``1``]` `        ``if` `curr.right ``and` `curr.right !``=` `prev:``            ``curr ``=` `curr.right``        ``else``:``            ``if` `curr.data ``=``=` `target:``                ``print``( ``"->"``.join(``map``(``str``, path)))``                ``return` `            ``node_stack.pop()``            ``path.pop()``            ``prev ``=` `curr``            ``curr ``=` `None` `    ``print``(``"No Path"``)` `# Driver program to test the function``if` `__name__ ``=``=` `"__main__"``:``    ``# Create a binary tree``    ``root ``=` `TreeNode(``1``)``    ``root.left ``=` `TreeNode(``2``)``    ``root.right ``=` `TreeNode(``3``)``    ``root.left.left ``=` `TreeNode(``4``)``    ``root.left.right ``=` `TreeNode(``5``)``    ``root.right.left ``=` `TreeNode(``6``)``    ``root.right.right ``=` `TreeNode(``7``)` `    ``target ``=` `5``    ``print_path(root, target)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// Structure of binary tree node``public` `class` `Node {``    ``public` `int` `data;``    ``public` `Node left;``    ``public` `Node right;` `    ``public` `Node(``int` `value)``    ``{``        ``data = value;``        ``left = right = ``null``;``    ``}``}` `class` `Program {``    ``// Function which will print the path``    ``static` `void` `PrintPath(Node root, ``int` `target)``    ``{``        ``List<``int``> path = ``new` `List<``int``>();``        ``Stack nodeStack = ``new` `Stack();``        ``Node curr = root;``        ``Node prev = ``null``;` `        ``while` `(curr != ``null` `|| nodeStack.Count > 0) {``            ``while` `(curr != ``null``) {``                ``nodeStack.Push(curr);``                ``path.Add(curr.data);``                ``curr = curr.left;``            ``}` `            ``curr = nodeStack.Peek();` `            ``if` `(curr.right != ``null` `&& curr.right != prev) {``                ``curr = curr.right;``            ``}``            ``else` `{``                ``if` `(curr.data == target) {``                    ``for` `(``int` `i = 0; i < path.Count - 1; i++)``                        ``Console.Write(path[i] + ``"->"``);``                    ``Console.WriteLine(path[path.Count - 1]);``                    ``return``;``                ``}` `                ``nodeStack.Pop();``                ``path.RemoveAt(path.Count - 1);``                ``prev = curr;``                ``curr = ``null``;``            ``}``        ``}``        ``Console.WriteLine(``"No Path"``);``    ``}` `    ``// Driver program to test above functions``    ``static` `void` `Main()``    ``{``        ``// Create a binary tree``        ``Node root = ``new` `Node(1);``        ``root.left = ``new` `Node(2);``        ``root.right = ``new` `Node(3);``        ``root.left.left = ``new` `Node(4);``        ``root.left.right = ``new` `Node(5);``        ``root.right.left = ``new` `Node(6);``        ``root.right.right = ``new` `Node(7);` `        ``int` `target = 5;``        ``PrintPath(root, target);``    ``}``}`

## Javascript

 `// Structure of binary tree node``class Node {``    ``constructor(value) {``        ``this``.data = value;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `// Function to print the path from root to a given node``function` `printPath(root, target) {``    ``let path = [];``    ``let nodeStack = [];``    ``let curr = root;``    ``let prev = ``null``;` `    ``while` `(curr || nodeStack.length > 0) {``        ``while` `(curr) {``            ``nodeStack.push(curr);``            ``path.push(curr.data);``            ``curr = curr.left;``        ``}` `        ``curr = nodeStack[nodeStack.length - 1];` `        ``if` `(curr.right && curr.right !== prev) {``            ``curr = curr.right;``        ``} ``else` `{``            ``if` `(curr.data === target) {``                ``for` `(let i = 0; i < path.length - 1; i++) {``                    ``process.stdout.write(path[i] + ``"->"``);``                ``}``                ``console.log(path[path.length - 1]);``                ``return``;``            ``}``            ``nodeStack.pop();``            ``path.pop();``            ``prev = curr;``            ``curr = ``null``;``        ``}``    ``}``    ``console.log(``"No Path"``);``}` `// Driver code to test the above functions``let root = ``new` `Node(1);``root.left = ``new` `Node(2);``root.right = ``new` `Node(3);``root.left.left = ``new` `Node(4);``root.left.right = ``new` `Node(5);``root.right.left = ``new` `Node(6);``root.right.right = ``new` `Node(7);` `let target = 5;``printPath(root, target);`

Output
```1->2->5

```

Time Complexity: O(N), where N is the number of nodes in given binary tree.

Auxiliary Space: O(H), where H is the height of the binary tree.

Previous
Next
Share your thoughts in the comments
Similar Reads