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

// C# implementation of the above approach 
using System;
using System.Collections;
using System.Collections.Generic;

class GFG
{
    static List<List<int>> v = new List<List<int>>();
    
    // 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

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);
    }
}