Find the node at the center of an N-ary tree

// C# implementation of
// the above approach
using System;
using System.Collections.Generic;
class GFG {
    
    // To create tree
    static Dictionary<int, List<int>> tree;
    static List<int> path;
    static int maxHeight, maxHeightNode;
     
    // Function to store the path
    // from given vertex to the target
    // vertex in a vector path
    static bool getDiameterPath(int vertex,
                                   int targetVertex,
                                   int parent,
                                   List<int> path)
    {
     
        // If the target node is found,
        // push it into path vector
        if (vertex == targetVertex)
        {
            path.Add(vertex);
            return true;
        }
     
        foreach(int i in tree[vertex])
        {
             
            // To prevent visiting a
            // node already visited
            if (i == parent)
                continue;
     
            // Recursive call to the neighbours
            // of current node inorder
            // to get the path
            if (getDiameterPath(i, targetVertex,
                                vertex, path))
            {
                path.Add(vertex);
                return true;
            }
        }
        return false;
    }
     
    // Function to obtain and return the
    // farthest node from a given vertex
    static void farthestNode(int vertex, int parent,
                             int height)
    {
         
        // If the current height is maximum
        // so far, then save the current node
        if (height > maxHeight)
        {
            maxHeight = height;
            maxHeightNode = vertex;
        }
     
        // Iterate over all the neighbours
        // of current node
        if (tree.ContainsKey(vertex) && tree[vertex].Count > 0)
        {
            foreach(int i in tree[vertex])
            {
                 
                // This is to prevent visiting
                // a already visited node
                if (i == parent)
                    continue;
     
                // Next call will be at 1 height
                // higher than our current height
                farthestNode(i, vertex, height + 1);
            }
        }
    }
     
    // Function to add edges
    static void addedge(int a, int b)
    {
        if (!tree.ContainsKey(a))
            tree[a] = new List<int>();
     
        tree[a].Add(b);
     
        if (!tree.ContainsKey(b))
            tree[b] = new List<int>();
     
        tree[b].Add(a);
    }
     
    static void FindCenter(int n)
    {
         
        // Now we will find the 1st farthest
        // node from 0(any arbitrary node)
     
        // Perform DFS from 0 and update
        // the maxHeightNode to obtain
        // the farthest node from 0
     
        // Reset to -1
        maxHeight = -1;
     
        // Reset to -1
        maxHeightNode = -1;
     
        farthestNode(0, -1, 0);
     
        // Stores one end of the diameter
        int leaf1 = maxHeightNode;
     
        // Similarly the other end of
        // the diameter
     
        // Reset the maxHeight
        maxHeight = -1;
        farthestNode(maxHeightNode,
                     -1, 0);
     
        // Stores the second end
        // of the diameter
        int leaf2 = maxHeightNode;
     
        // Store the diameter into
        // the vector path
        path = new List<int>();
     
        // Diameter is equal to the
        // path between the two farthest
        // nodes leaf1 and leaf2
        getDiameterPath(leaf1, leaf2,
                        -1, path);
     
        int pathSize = path.Count;
     
        if (pathSize % 2 == 1)
        {
            Console.WriteLine(path[pathSize / 2]);
        }
        else {
            Console.WriteLine(path[pathSize / 2] +
                        ", " + path[(pathSize - 1) / 2]);
        }
    }

  static void Main() {
    int N = 4;
 
    tree = new Dictionary<int, List<int>>();
    addedge(1, 0);
    addedge(1, 2);
    addedge(1, 3);
 
    FindCenter(N);
  }
}

// This code is contributed by divyesh072019.