# Print the path between any two nodes of a tree | DFS

Given a tree of distinct nodes N with N-1 edges and a pair of nodes P. The task is to find and print the path between the two given nodes of the tree using DFS.

```Input: N = 10
1
/    \
2      3
/ | \  / | \
4  5 6  7 8  9
Pair = {4, 8}
Output: 4 -> 2 -> 1 -> 3 -> 8

Input: N = 3
1
/  \
2    3
Pair = {2, 3}
Output:  2 -> 1 -> 3```

For example, in the above tree the path between nodes 5 and 3 is 5 -> 2 -> 1 -> 3
Path between nodes 4 and 8 is 4 -> 2 -> 1 -> 3 -> 8.

Approach:

• The idea is to run DFS from the source node and push the traversed nodes into a stack till the destination node is traversed.
• Whenever backtracking occurs pop the node from the stack.

Note: There should be a path between the given pair of nodes.

Below is the implementation of the above approach:

## C++

 `// C++ implementation``#include ``using` `namespace` `std;` `// An utility function to add an edge in an``// undirected graph.``void` `addEdge(vector<``int``> v[],``             ``int` `x,``             ``int` `y)``{``    ``v[x].push_back(y);``    ``v[y].push_back(x);``}` `// A function to print the path between``// the given pair of nodes.``void` `printPath(vector<``int``> stack)``{``    ``int` `i;``    ``for` `(i = 0; i < (``int``)stack.size() - 1;``         ``i++) {``        ``cout << stack[i] << ``" -> "``;``    ``}``    ``cout << stack[i];``}` `// An utility function to do``// DFS of graph recursively``// from a given vertex x.``void` `DFS(vector<``int``> v[],``         ``bool` `vis[],``         ``int` `x,``         ``int` `y,``         ``vector<``int``> stack)``{``    ``stack.push_back(x);``    ``if` `(x == y) {` `        ``// print the path and return on``        ``// reaching the destination node``        ``printPath(stack);``        ``return``;``    ``}``    ``vis[x] = ``true``;` `    ``// if backtracking is taking place``    ``if` `(!v[x].empty()) {``        ``for` `(``int` `j = 0; j < v[x].size(); j++) {``            ``// if the node is not visited``            ``if` `(vis[v[x][j]] == ``false``)``                ``DFS(v, vis, v[x][j], y, stack);``        ``}``    ``}` `    ``stack.pop_back();``}` `// A utility function to initialise``// visited for the node and call``// DFS function for a given vertex x.``void` `DFSCall(``int` `x,``             ``int` `y,``             ``vector<``int``> v[],``             ``int` `n,``             ``vector<``int``> stack)``{``    ``// visited array``    ``bool` `vis[n + 1];` `    ``memset``(vis, ``false``, ``sizeof``(vis));` `    ``// DFS function call``    ``DFS(v, vis, x, y, stack);``}` `// Driver Code``int` `main()``{``    ``int` `n = 10;``    ``vector<``int``> v[n], stack;` `    ``// Vertex numbers should be from 1 to 9.``    ``addEdge(v, 1, 2);``    ``addEdge(v, 1, 3);``    ``addEdge(v, 2, 4);``    ``addEdge(v, 2, 5);``    ``addEdge(v, 2, 6);``    ``addEdge(v, 3, 7);``    ``addEdge(v, 3, 8);``    ``addEdge(v, 3, 9);` `    ``// Function Call``    ``DFSCall(4, 8, v, n, stack);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach ``import` `java.util.*;``class` `GFG``{``    ``static` `Vector> v = ``new` `Vector>();``    ` `    ``// An utility function to add an edge in an ``    ``// undirected graph. ``    ``static` `void` `addEdge(``int` `x, ``int` `y){ ``        ``v.get(x).add(y); ``        ``v.get(y).add(x);``    ``}``    ` `    ``// A function to print the path between ``    ``// the given pair of nodes. ``    ``static` `void` `printPath(Vector stack)``    ``{``        ``for``(``int` `i = ``0``; i < stack.size() - ``1``; i++)``        ``{``            ``System.out.print(stack.get(i) + ``" -> "``);``        ``}``        ``System.out.println(stack.get(stack.size() - ``1``));``    ``}``    ` `    ``// An utility function to do ``    ``// DFS of graph recursively ``    ``// from a given vertex x. ``    ``static` `void` `DFS(``boolean` `vis[], ``int` `x, ``int` `y, Vector stack)``    ``{``        ``stack.add(x); ``        ``if` `(x == y)``        ``{``          ` `            ``// print the path and return on ``            ``// reaching the destination node ``            ``printPath(stack); ``            ``return``;``        ``}``        ``vis[x] = ``true``;``      ` `        ``// if backtracking is taking place      ``        ``if` `(v.get(x).size() > ``0``)``        ``{``            ``for``(``int` `j = ``0``; j < v.get(x).size(); j++)``            ``{``              ` `                ``// if the node is not visited ``                ``if` `(vis[v.get(x).get(j)] == ``false``)``                ``{``                    ``DFS(vis, v.get(x).get(j), y, stack);``                ``}``            ``}``        ``} ``        ` `        ``stack.remove(stack.size() - ``1``);``    ``}``    ` `    ``// A utility function to initialise ``    ``// visited for the node and call ``    ``// DFS function for a given vertex x. ``    ``static` `void` `DFSCall(``int` `x, ``int` `y, ``int` `n,``                        ``Vector stack)``    ``{``      ` `        ``// visited array ``        ``boolean` `vis[] = ``new` `boolean``[n + ``1``]; ``        ``Arrays.fill(vis, ``false``);``      ` `        ``// memset(vis, false, sizeof(vis)) ``      ` `        ``// DFS function call ``        ``DFS(vis, x, y, stack);``    ``}``    ` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``for``(``int` `i = ``0``; i < ``100``; i++)``        ``{``            ``v.add(``new` `Vector());``        ``}``    ` `        ``int` `n = ``10``;``        ``Vector stack = ``new` `Vector();``          ` `        ``// Vertex numbers should be from 1 to 9. ``        ``addEdge(``1``, ``2``); ``        ``addEdge(``1``, ``3``);``        ``addEdge(``2``, ``4``);``        ``addEdge(``2``, ``5``);``        ``addEdge(``2``, ``6``);``        ``addEdge(``3``, ``7``);``        ``addEdge(``3``, ``8``);``        ``addEdge(``3``, ``9``);``          ` `        ``// Function Call ``        ``DFSCall(``4``, ``8``, n, stack); ``    ``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 implementation of the above approach``v ``=` `[[] ``for` `i ``in` `range``(``100``)]` `# An utility function to add an edge in an``# undirected graph.``def` `addEdge(x, y):``    ``v[x].append(y)``    ``v[y].append(x)` `# A function to print the path between``# the given pair of nodes.``def` `printPath(stack):``    ``for` `i ``in` `range``(``len``(stack) ``-` `1``):``        ``print``(stack[i], end ``=` `" -> "``)``    ``print``(stack[``-``1``])` `# An utility function to do``# DFS of graph recursively``# from a given vertex x.``def` `DFS(vis, x, y, stack):``    ``stack.append(x)``    ``if` `(x ``=``=` `y):` `        ``# print the path and return on``        ``# reaching the destination node``        ``printPath(stack)``        ``return``    ``vis[x] ``=` `True` `    ``# if backtracking is taking place` `    ``if` `(``len``(v[x]) > ``0``):``        ``for` `j ``in` `v[x]:``            ` `            ``# if the node is not visited``            ``if` `(vis[j] ``=``=` `False``):``                ``DFS(vis, j, y, stack)``                ` `    ``del` `stack[``-``1``]` `# A utility function to initialise``# visited for the node and call``# DFS function for a given vertex x.``def` `DFSCall(x, y, n, stack):``    ` `    ``# visited array``    ``vis ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    ``#memset(vis, false, sizeof(vis))` `    ``# DFS function call``    ``DFS(vis, x, y, stack)` `# Driver Code``n ``=` `10``stack ``=` `[]` `# Vertex numbers should be from 1 to 9.``addEdge(``1``, ``2``)``addEdge(``1``, ``3``)``addEdge(``2``, ``4``)``addEdge(``2``, ``5``)``addEdge(``2``, ``6``)``addEdge(``3``, ``7``)``addEdge(``3``, ``8``)``addEdge(``3``, ``9``)` `# Function Call``DFSCall(``4``, ``8``, n, stack)``    ` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the above approach ``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG``{``    ``static` `List> v = ``new` `List>();``    ` `    ``// An utility function to Add an edge in an ``    ``// undirected graph. ``    ``static` `void` `addEdge(``int` `x, ``int` `y)``    ``{ ``        ``v[x].Add(y); ``        ``v[y].Add(x);``    ``}``    ` `    ``// A function to print the path between ``    ``// the given pair of nodes. ``    ``static` `void` `printPath(List<``int``> stack)``    ``{``        ``for``(``int` `i = 0; i < stack.Count - 1; i++)``        ``{``            ``Console.Write(stack[i] + ``" -> "``);``        ``}``        ``Console.WriteLine(stack[stack.Count - 1]);``    ``}``    ` `    ``// An utility function to do ``    ``// DFS of graph recursively ``    ``// from a given vertex x. ``    ``static` `void` `DFS(``bool` `[]vis, ``int` `x, ``int` `y, List<``int``> stack)``    ``{``        ``stack.Add(x); ``        ``if` `(x == y)``        ``{``          ` `            ``// print the path and return on ``            ``// reaching the destination node ``            ``printPath(stack); ``            ``return``;``        ``}``        ``vis[x] = ``true``;``      ` `        ``// if backtracking is taking place      ``        ``if` `(v[x].Count > 0)``        ``{``            ``for``(``int` `j = 0; j < v[x].Count; j++)``            ``{``              ` `                ``// if the node is not visited ``                ``if` `(vis[v[x][j]] == ``false``)``                ``{``                    ``DFS(vis, v[x][j], y, stack);``                ``}``            ``}``        ``}         ``        ``stack.RemoveAt(stack.Count - 1);``    ``}``    ` `    ``// A utility function to initialise ``    ``// visited for the node and call ``    ``// DFS function for a given vertex x. ``    ``static` `void` `DFSCall(``int` `x, ``int` `y, ``int` `n,``                        ``List<``int``> stack)``    ``{``      ` `        ``// visited array ``        ``bool` `[]vis = ``new` `bool``[n + 1]; ``        ``Array.Fill(vis, ``false``);``      ` `        ``// memset(vis, false, sizeof(vis)) ``      ` `        ``// DFS function call ``        ``DFS(vis, x, y, stack);``    ``}``    ` `  ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``for``(``int` `i = 0; i < 100; i++)``        ``{``            ``v.Add(``new` `List<``int``>());``        ``}``    ` `        ``int` `n = 10;``        ``List<``int``> stack = ``new` `List<``int``>();``          ` `        ``// Vertex numbers should be from 1 to 9. ``        ``addEdge(1, 2); ``        ``addEdge(1, 3);``        ``addEdge(2, 4);``        ``addEdge(2, 5);``        ``addEdge(2, 6);``        ``addEdge(3, 7);``        ``addEdge(3, 8);``        ``addEdge(3, 9);``          ` `        ``// Function Call ``        ``DFSCall(4, 8, n, stack); ``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:
`4 -> 2 -> 1 -> 3 -> 8`

Efficient Approach :

In this approach we will utilise the concept of Lowest Common Ancestor (LCA).

1. We will find level and parent of every node using DFS.

2. We will find lowest common ancestor (LCA) of the two given nodes.

3. Starting from the first node we will travel to the LCA and keep on pushing

the intermediates nodes in our path vector.

4. Then, from the second node we will again travel to the LCA but this time

we will reverse the encountered intermediate nodes and then push them in

our path vector.

5. Finally, print the path vector to get the path between the two nodes.

## C++

 `// C++ implementation for the above approach``#include ``using` `namespace` `std;` `// An utility function to add an edge in the tree``void` `addEdge(vector<``int``> adj[], ``int` `x,``             ``int` `y)``{``    ``adj[x].push_back(y);``    ``adj[y].push_back(x);``}` `// running dfs to find level and parent of every node``void` `dfs(vector<``int``> adj[], ``int` `node, ``int` `l, ``            ``int` `p, ``int` `lvl[], ``int` `par[])``{``   ``lvl[node] = l;``   ``par[node] = p;``  ` `   ``for``(``int` `child : adj[node])``   ``{``      ``if``(child != p)``        ``dfs(adj, child, l+1, node, lvl, par);``   ``}``}` `int` `LCA(``int` `a, ``int` `b, ``int` `par[], ``int` `lvl[])``{  ``   ``// if node a is at deeper level than ``   ``// node b``   ``if``(lvl[a] > lvl[b])``    ``swap(a, b);``   ` `   ``// finding the difference in levels``   ``// of node a and b``   ``int` `diff = lvl[b] - lvl[a];``   ` `   ``// moving b to the level of a``   ``while``(diff != 0)``   ``{``      ``b = par[b];``      ``diff--;``   ``}``   ` `   ``// means we have found the LCA``   ``if``(a == b)``    ``return` `a;``   ` `   ``// finding the LCA``   ``while``(a != b)``    ``a=par[a], b=par[b];` `   ``return` `a;``}` `void` `printPath(vector<``int``> adj[], ``int` `a, ``int` `b, ``int` `n)``{``    ``// stores level of every node``    ``int` `lvl[n+1];``  ` `    ``// stores parent of every node``    ``int` `par[n+1];``  ` `    ``// running dfs to find parent and level``    ``// of every node in the tree``    ``dfs(adj, 1, 0, -1, lvl, par);``    ` `    ``// finding the lowest common ancestor``    ``// of the nodes a and b``    ``int` `lca = LCA(a, b, par, lvl);``  ` `    ``// stores path between nodes a and b``    ``vector<``int``> path;``    ` `    ``// traversing the path from a to lca``    ``while``(a != lca)``      ``path.push_back(a), a = par[a];` `    ``path.push_back(a);` `    ``vector<``int``> temp;``    ` `    ``// traversing the path from b to lca``    ``while``(b != lca)``      ``temp.push_back(b), b=par[b];``    ` `    ``// reversing the path to get actual path ``    ``reverse(temp.begin(), temp.end());``  ` `    ``for``(``int` `x : temp)``      ``path.push_back(x);``  ` `    ``// printing the path``    ``for``(``int` `i = 0; i < path.size() - 1; i++)``      ``cout << path[i] << ``" -> "``;``  ` `    ``cout << path[path.size() - 1] << endl;``}` `// Driver Code``int` `main() ``{   ``  ``/*                          1`` ` `                        ``/            \` `                     ``2                7` `               ``/             \` `             ``3                6` `    ``/        |        \` `  ``4          8          5``  ` ` ``*/``    ``// number of nodes in the tree``    ``int` `n = 8;``    ` `    ``// adjacency list representation of the tree``    ``vector<``int``> adj[n+1];``  ` `    ``addEdge(adj, 1, 2);``    ``addEdge(adj, 1, 7);``    ``addEdge(adj, 2, 3);``    ``addEdge(adj, 2, 6);``    ``addEdge(adj, 3, 4);``    ``addEdge(adj, 3, 8);``    ``addEdge(adj, 3, 5);``    ` `    ``// taking two input nodes``    ``// between which path is``    ``// to be printed``    ``int` `a = 4, b = 7;``  ` `    ``printPath(adj, a, b, n);``   ` `    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``  ``public` `static` `void` `main(String[] args)``  ``{``    ``/*                          1` `                          ``/            \` `                       ``2                7` `                 ``/             \` `               ``3                6` `      ``/        |        \` `    ``4          8          5` `   ``*/``    ``// number of nodes in the tree``    ``int` `n = ``8``;` `    ``// adjacency list representation of the tree``    ``ArrayList[] adj = ``new` `ArrayList[n + ``1``];``    ``for` `(``int` `i = ``0``; i <= n; i++) {``      ``adj[i] = ``new` `ArrayList<>();``    ``}` `    ``addEdge(adj, ``1``, ``2``);``    ``addEdge(adj, ``1``, ``7``);``    ``addEdge(adj, ``2``, ``3``);``    ``addEdge(adj, ``2``, ``6``);``    ``addEdge(adj, ``3``, ``4``);``    ``addEdge(adj, ``3``, ``8``);``    ``addEdge(adj, ``3``, ``5``);` `    ``// taking two input nodes``    ``// between which path is``    ``// to be printed``    ``int` `a = ``4``, b = ``7``;` `    ``printPath(adj, a, b, n);``  ``}` `  ``public` `static` `void` `addEdge(ArrayList[] adj,``                             ``int` `x, ``int` `y)``  ``{``    ``adj[x].add(y);``    ``adj[y].add(x);``  ``}` `  ``// running dfs to find level and parent of every node``  ``public` `static` `void` `dfs(ArrayList[] adj,``                         ``int` `node, ``int` `l, ``int` `p,``                         ``int``[] lvl, ``int``[] par)``  ``{``    ``lvl[node] = l;``    ``par[node] = p;` `    ``for` `(``int` `child : adj[node]) {``      ``if` `(child != p) {``        ``dfs(adj, child, l + ``1``, node, lvl, par);``      ``}``    ``}``  ``}` `  ``public` `static` `int` `LCA(``int` `a, ``int` `b, ``int``[] par,``                        ``int``[] lvl)``  ``{``    ``// if node a is at deeper level than``    ``// node b``    ``if` `(lvl[a] > lvl[b]) {``      ``int` `temp = a;``      ``a = b;``      ``b = temp;``    ``}` `    ``// finding the difference in levels``    ``// of node a and b``    ``int` `diff = lvl[b] - lvl[a];` `    ``// moving b to the level of a``    ``while` `(diff != ``0``) {``      ``b = par[b];``      ``diff--;``    ``}` `    ``// means we have found the LCA``    ``if` `(a == b) {``      ``return` `a;``    ``}` `    ``// finding the LCA``    ``while` `(a != b) {``      ``a = par[a];``      ``b = par[b];``    ``}` `    ``return` `a;``  ``}` `  ``public` `static` `void` `printPath(ArrayList[] adj,``                               ``int` `a, ``int` `b, ``int` `n)``  ``{``    ``// stores level of every node``    ``int``[] lvl = ``new` `int``[n + ``1``];``    ``// stores parent of every node``    ``int``[] par = ``new` `int``[n + ``1``];` `    ``// running dfs to find parent and level``    ``// of every node in the tree``    ``dfs(adj, ``1``, ``0``, -``1``, lvl, par);` `    ``// finding the lowest common ancestor``    ``// of the nodes a and b``    ``int` `lca = LCA(a, b, par, lvl);` `    ``ArrayList path = ``new` `ArrayList<>();` `    ``// traversing the path from a to lca``    ``while` `(a != lca) {``      ``path.add(a);``      ``a = par[a];``    ``}` `    ``path.add(a);` `    ``ArrayList temp = ``new` `ArrayList<>();` `    ``// traversing the path from b to lca``    ``while` `(b != lca) {``      ``temp.add(b);``      ``b = par[b];``    ``}` `    ``// reversing the path to get actual path``    ``Collections.reverse(temp);` `    ``path.addAll(temp);` `    ``// printing the path``    ``for` `(``int` `i = ``0``; i < path.size() - ``1``; i++) {``      ``System.out.print(path.get(i) + ``" -> "``);``    ``}` `    ``System.out.println(path.get(path.size() - ``1``));``  ``}``}` `// This code is contributed by divyansh2212`

## Python3

 `from` `collections ``import` `defaultdict``#An utility function to add an edge in the tree``def` `add_edge(adj, x, y):``    ``adj[x].append(y)``    ``adj[y].append(x)``# running dfs to find level and parent of every node``def` `dfs(adj, node, l, p, lvl, par):``    ``lvl[node] ``=` `l``    ``par[node] ``=` `p``   ``# if node a is at deeper level than ``   ``# node b``    ``for` `child ``in` `adj[node]:``        ``if` `child !``=` `p:``            ``dfs(adj, child, l ``+` `1``, node, lvl, par)` `def` `LCA(a, b, par, lvl):  ``    ``if` `lvl[a] > lvl[b]:``        ``a, b ``=` `b, a``        ``# finding the difference in levels``   ``# of node a and b``    ``diff ``=` `lvl[b] ``-` `lvl[a]``    ``while` `diff !``=` `0``:``        ``b ``=` `par[b]``        ``diff ``-``=` `1``    ``if` `a ``=``=` `b:``        ``return` `a``    ``while` `a !``=` `b:``        ``a ``=` `par[a]``        ``b ``=` `par[b]``    ``return` `a` `def` `print_path(adj, a, b, n):``    ``lvl ``=` `[``0``] ``*` `(n ``+` `1``)``    ``par ``=` `[``0``] ``*` `(n ``+` `1``)``    ``dfs(adj, ``1``, ``0``, ``-``1``, lvl, par)``    ``lca ``=` `LCA(a, b, par, lvl)``    ``path ``=` `[]``    ``while` `a !``=` `lca:``        ``path.append(a)``        ``a ``=` `par[a]``    ``path.append(a)``    ``temp ``=` `[]``    ``while` `b !``=` `lca:``        ``temp.append(b)``        ``b ``=` `par[b]``    ``temp.reverse()``    ``for` `x ``in` `temp:``        ``path.append(x)``    ``print``(``" -> "``.join(``map``(``str``, path)))` `if` `__name__ ``=``=` `"__main__"``:``    ``n ``=` `8``    ``adj ``=` `defaultdict(``list``)``    ``add_edge(adj, ``1``, ``2``)``    ``add_edge(adj, ``1``, ``7``)``    ``add_edge(adj, ``2``, ``3``)``    ``add_edge(adj, ``2``, ``6``)``    ``add_edge(adj, ``3``, ``4``)``    ``add_edge(adj, ``3``, ``8``)``    ``add_edge(adj, ``3``, ``5``)``    ``#   taking two input nodes``    ``# between which path is``    ``#to be printed``    ``a, b ``=` `4``, ``7``    ``print_path(adj, a, b, n)`

## Javascript

 `// Function to add an edge to an adjacency list``function` `addEdge(adj, x, y) {``  ``adj[x].push(y);``  ``adj[y].push(x);``}` `// Function to perform depth first search (DFS) traversal``// and compute level and parent information for each node``function` `dfs(adj, node, l, p, lvl, par) {``  ``lvl[node] = l; ``// set level of current node``  ``par[node] = p; ``// set parent of current node` `  ``// Traverse through all adjacent nodes``  ``for` `(let i = 0; i < adj[node].length; i++) {``    ``let child = adj[node][i];``    ``// If the adjacent node is not the parent of the current node,``    ``// perform DFS on the adjacent node``    ``if` `(child !== p) {``      ``dfs(adj, child, l + 1, node, lvl, par);``    ``}``  ``}``}` `// Function to find the lowest common ancestor (LCA) of two nodes``function` `LCA(a, b, par, lvl) {``  ``// Make sure that node a is at a lower level than node b``  ``if` `(lvl[a] > lvl[b]) {``    ``let temp = a;``    ``a = b;``    ``b = temp;``  ``}``  ``// Compute the difference in levels between node a and node b``  ``let diff = lvl[b] - lvl[a];` `  ``// Move up the tree from node b to reach the same level as node a``  ``while` `(diff !== 0) {``    ``b = par[b];``    ``diff--;``  ``}` `  ``// If node a and node b are the same, then they are the LCA``  ``if` `(a === b) {``    ``return` `a;``  ``}` `  ``// Move up the tree from both nodes until they have the same parent``  ``while` `(a !== b) {``    ``a = par[a];``    ``b = par[b];``  ``}` `  ``// The parent of the common ancestor is the LCA``  ``return` `a;``}` `// Function to print the path between two nodes in a tree``function` `printPath(adj, a, b, n) {``  ``// Initialize arrays to store level and parent information``  ``let lvl = ``new` `Array(n + 1).fill(0);``  ``let par = ``new` `Array(n + 1).fill(0);` `  ``// Perform DFS traversal and compute level and parent information``  ``dfs(adj, 1, 0, -1, lvl, par);` `  ``// Find the lowest common ancestor of nodes a and b``  ``let lca = LCA(a, b, par, lvl);``  ``// Initialize an array to store the path between nodes a and b``  ``let path = [];` `  ``// Traverse from node a to the LCA and add all nodes to the path``  ``while` `(a !== lca) {``    ``path.push(a);``    ``a = par[a];``  ``}` `  ``// Add the LCA to the path``  ``path.push(a);``  ``// Initialize a temporary array to store the path from node b to the LCA``  ``let temp = [];` `  ``// Traverse from node b to the LCA and add all nodes to the temporary array``  ``while` `(b !== lca) {``    ``temp.push(b);``    ``b = par[b];``  ``}` `  ``// Reverse the temporary array and add its elements to the path``  ``temp.reverse();``  ``path.push(...temp);` `  ``// Print the path``  ``for` `(let i = 0; i < path.length - 1; i++) {``    ``process.stdout.write(path[i] + ``" -> "``);``  ``}``  ``console.log(path[path.length - 1]);``}` `let n = 8;``let adj = ``new` `Array(n + 1);` `for` `(let i = 0; i <= n; i++) {``  ``adj[i] = [];``}` `addEdge(adj, 1, 2);``addEdge(adj, 1, 7);``addEdge(adj, 2, 3);``addEdge(adj, 2, 6);``addEdge(adj, 3, 4);``addEdge(adj, 3, 8);``addEdge(adj, 3, 5);` `let a = 4,``  ``b = 7;` `printPath(adj, a, b, n);`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `public` `class` `GFG``{``    ``// An utility function to add an edge in the tree``    ``static` `void` `addEdge(List<``int``>[] adj, ``int` `x, ``int` `y)``    ``{``        ``adj[x].Add(y);``        ``adj[y].Add(x);``    ``}` `    ``// running dfs to find level and parent of every node``    ``static` `void` `dfs(List<``int``>[] adj, ``int` `node, ``int` `l, ``int` `p, ``int``[] lvl, ``int``[] par)``    ``{``        ``lvl[node] = l;``        ``par[node] = p;` `        ``foreach` `(``int` `child ``in` `adj[node])``        ``{``            ``if` `(child != p)``                ``dfs(adj, child, l + 1, node, lvl, par);``        ``}``    ``}` `    ``static` `int` `LCA(``int` `a, ``int` `b, ``int``[] par, ``int``[] lvl)``    ``{``        ``// if node a is at deeper level than node b``        ``if` `(lvl[a] > lvl[b])``            ``(a, b) = (b, a);` `        ``// finding the difference in levels of node a and b``        ``int` `diff = lvl[b] - lvl[a];` `        ``// moving b to the level of a``        ``while` `(diff != 0)``        ``{``            ``b = par[b];``            ``diff--;``        ``}` `        ``// means we have found the LCA``        ``if` `(a == b)``            ``return` `a;` `        ``// finding the LCA``        ``while` `(a != b)``            ``(a, b) = (par[a], par[b]);` `        ``return` `a;``    ``}` `    ``static` `void` `printPath(List<``int``>[] adj, ``int` `a, ``int` `b, ``int` `n)``    ``{``        ``// stores level of every node``        ``int``[] lvl = ``new` `int``[n + 1];` `        ``// stores parent of every node``        ``int``[] par = ``new` `int``[n + 1];` `        ``// running dfs to find parent and level``        ``// of every node in the tree``        ``dfs(adj, 1, 0, -1, lvl, par);` `        ``// finding the lowest common ancestor``        ``// of the nodes a and b``        ``int` `lca = LCA(a, b, par, lvl);` `        ``// stores path between nodes a and b``        ``List<``int``> path = ``new` `List<``int``>();` `        ``// traversing the path from a to lca``        ``while` `(a != lca)``        ``{``            ``path.Add(a);``            ``a = par[a];``        ``}` `        ``path.Add(a);` `        ``List<``int``> temp = ``new` `List<``int``>();` `        ``// traversing the path from b to lca``        ``while` `(b != lca)``        ``{``            ``temp.Add(b);``            ``b = par[b];``        ``}` `        ``// reversing the path to get actual path``        ``temp.Reverse();` `        ``foreach` `(``int` `x ``in` `temp)``            ``path.Add(x);` `        ``// printing the path``        ``for` `(``int` `i = 0; i < path.Count() - 1; i++)``            ``Console.Write(path[i] + ``" -> "``);` `        ``Console.WriteLine(path[path.Count() - 1]);``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``{``                    ``/*          1`` ` `                          ``/            \`` ` `                       ``2                7`` ` `                 ``/             \`` ` `               ``3                6`` ` `      ``/        |        \`` ` `    ``4          8          5`` ` `   ``*/``        ``// number of nodes in the tree``        ``int` `n = 8;` `        ``// adjacency list representation of the tree``        ``List<``int``>[] adj = ``new` `List<``int``>[n + 1];``        ``for` `(``int` `i = 0; i <= n; i++)``        ``{``            ``adj[i] = ``new` `List<``int``>();``        ``}` `        ``addEdge(adj, 1, 2);``        ``addEdge(adj, 1, 7);``        ``addEdge(adj, 2, 3);``        ``addEdge(adj, 2, 6);``        ``addEdge(adj, 3, 4);``        ``addEdge(adj, 3, 8);``        ``addEdge(adj, 3, 5);` `        ``// taking two input nodes``        ``// between which path is``        ``// to be printed``        ``int` `a = 4, b = 7;` `        ``printPath(adj, a, b, n);``    ``}``}`

Output
`4 -> 3 -> 2 -> 1 -> 7`

Time Complexity : O(N)

Space Complexity : O(N)

Previous
Next