Diameter of a tree using DFS

10 Jun, 2022
The diameter of a tree (sometimes called the width) is the number of nodes on the longest path between two leaves in the tree. The diagram below shows two trees each with a diameter of five, the leaves that form the ends of the longest path are shaded (note that there is more than one path in each tree of length five, but no path longer than five nodes)  
 
We have discussed a solution in the below postDiameter of a binary treeIn this post, a different DFS-based solution is discussed. After observing the above tree we can see that the longest path will always occur between two leaf nodes. We start DFS from a random node and then see which node is farthest from it. Let the node farthest be X. It is clear that X will always be a leaf node and a corner of DFS. Now if we start DFS from X and check the farthest node from it, we will get the diameter of the tree. The C++ implementation uses an adjacency list representation of graphs. STL‘s list container is used to store lists of adjacent nodes.  
C++
Java
Python3
C#
Javascript
// C++ program to find diameter of a binary tree// using DFS.#include <iostream>#include <limits.h>#include <list>using namespace std; // Used to track farthest node.int x; // Sets maxCount as maximum distance from node.void dfsUtil(int node, int count, bool visited[],                   int& maxCount, list<int>* adj){    visited[node] = true;    count++;    for (auto i = adj[node].begin(); i != adj[node].end(); ++i) {        if (!visited[*i]) {            if (count >= maxCount) {                maxCount = count;                x = *i;            }            dfsUtil(*i, count, visited, maxCount, adj);        }    }} // The function to do DFS traversal. It uses recursive// dfsUtil()void dfs(int node, int n, list<int>* adj, int& maxCount){    bool visited[n + 1];    int count = 0;     // Mark all the vertices as not visited    for (int i = 1; i <= n; ++i)        visited[i] = false;     // Increment count by 1 for visited node    dfsUtil(node, count + 1, visited, maxCount, adj);} // Returns diameter of binary tree represented// as adjacency list.int diameter(list<int>* adj, int n){    int maxCount = INT_MIN;     /* DFS from a random node and then see    farthest node X from it*/    dfs(1, n, adj, maxCount);     /* DFS from X and check the farthest node    from it */    dfs(x, n, adj, maxCount);     return maxCount;} /* Driver program to test above functions*/int main(){    int n = 5;     /* Constructed tree is         1        / \        2    3       / \      4   5 */    list<int>* adj = new list<int>[n + 1];     /*create undirected edges */    adj[1].push_back(2);    adj[2].push_back(1);    adj[1].push_back(3);    adj[3].push_back(1);    adj[2].push_back(4);    adj[4].push_back(2);    adj[2].push_back(5);    adj[5].push_back(2);      /* maxCount will have diameter of tree */    cout << "Diameter of the given tree is "        << diameter(adj, n) << endl;    return 0;}
// Java program to find diameter of a// binary tree using DFS.import java.util.ArrayList;import java.util.Arrays;import java.util.List;public class Diametre_tree {      // Used to track farthest node.    static int x;    static int maxCount;    static List<Integer> adj[];         // Sets maxCount as maximum distance    // from node    static void dfsUtil(int node, int count,                         boolean visited[],                       List<Integer> adj[])    {        visited[node] = true;        count++;                 List<Integer> l = adj[node];        for(Integer i: l)        {            if(!visited[i]){                if (count >= maxCount) {                    maxCount = count;                    x = i;                }                dfsUtil(i, count, visited, adj);            }        }    }          // The function to do DFS traversal. It uses    // recursive dfsUtil()    static void dfs(int node, int n, List<Integer>                                       adj[])    {        boolean[] visited = new boolean[n + 1];        int count = 0;              // Mark all the vertices as not visited        Arrays.fill(visited, false);              // Increment count by 1 for visited node        dfsUtil(node, count + 1, visited, adj);             }          // Returns diameter of binary tree represented    // as adjacency list.    static int diameter(List<Integer> adj[], int n)    {        maxCount = Integer.MIN_VALUE;              /* DFS from a random node and then see        farthest node X from it*/        dfs(1, n, adj);              /* DFS from X and check the farthest node        from it */        dfs(x, n, adj);              return maxCount;    }          /* Driver program to test above functions*/    public static void main(String args[])    {        int n = 5;              /* Constructed tree is             1            / \            2    3           / \          4   5 */        adj = new List[n + 1];        for(int i = 0; i < n+1 ; i++)            adj[i] = new ArrayList<Integer>();              /*create undirected edges */        adj[1].add(2);        adj[2].add(1);        adj[1].add(3);        adj[3].add(1);        adj[2].add(4);        adj[4].add(2);        adj[2].add(5);        adj[5].add(2);                 /* maxCount will have diameter of tree */        System.out.println("Diameter of the given " +                       "tree is " + diameter(adj, n));    }}// This code is contributed by Sumit Ghosh
# Python3 program to find diameter of a binary tree# using DFS. # Sets maxCount as maximum distance from node.def dfsUtil(node, count):    global visited, x, maxCount, adj    visited[node] = 1    count += 1    for i in adj[node]:        if (visited[i] == 0):            if (count >= maxCount):                maxCount = count                x = i            dfsUtil(i, count) # The function to do DFS traversal. It uses recursive# dfsUtil()def dfs(node, n):    count = 0    for i in range(n + 1):        visited[i] = 0     # Increment count by 1 for visited node    dfsUtil(node, count + 1) # Returns diameter of binary tree represented# as adjacency list.def diameter(n):    global adj, maxCount     # DFS from a random node and then see    # farthest node X from it*/    dfs(1, n)     # DFS from X and check the farthest node    dfs(x, n)    return maxCount ## Driver code*/if __name__ == '__main__':    n = 5     # # Constructed tree is    #      1    #     / \    #     2    3    #    / \    #   4   5 */    adj, visited = [[] for i in range(n + 1)], [0 for i in range(n + 1)]    maxCount = -10**19    x = 0     # create undirected edges */    adj[1].append(2)    adj[2].append(1)    adj[1].append(3)    adj[3].append(1)    adj[2].append(4)    adj[4].append(2)    adj[2].append(5)    adj[5].append(2)     # maxCount will have diameter of tree */    print ("Diameter of the given tree is ", diameter(n))     # This code is contributed by mohit kumar 29
// C# program to find diameter of a// binary tree using DFS.using System;using System.Collections.Generic; class GFG{     // Used to track farthest node.    static int x;    static int maxCount;    static List<int> []adj;         // Sets maxCount as maximum distance    // from node    static void dfsUtil(int node, int count,                             bool []visited,                            List<int> []adj)    {        visited[node] = true;        count++;                 List<int> l = adj[node];        foreach(int i in l)        {            if(!visited[i])            {                if (count >= maxCount)                {                    maxCount = count;                    x = i;                }                dfsUtil(i, count, visited, adj);            }        }    }         // The function to do DFS traversal. It uses    // recursive dfsUtil()    static void dfs(int node, int n,                    List<int> []adj)    {        bool[] visited = new bool[n + 1];        int count = 0;              // Increment count by 1 for visited node        dfsUtil(node, count + 1, visited, adj);    }         // Returns diameter of binary tree represented    // as adjacency list.    static int diameter(List<int> []adj, int n)    {        maxCount = int.MinValue;             /* DFS from a random node and then see        farthest node X from it*/        dfs(1, n, adj);             /* DFS from X and check the farthest node        from it */        dfs(x, n, adj);             return maxCount;    }         // Driver Code    public static void Main(String []args)    {        int n = 5;             /* Constructed tree is            1            / \            2 3        / \        4 5 */        adj = new List<int>[n + 1];        for(int i = 0; i < n + 1; i++)            adj[i] = new List<int>();             /*create undirected edges */        adj[1].Add(2);        adj[2].Add(1);        adj[1].Add(3);        adj[3].Add(1);        adj[2].Add(4);        adj[4].Add(2);        adj[2].Add(5);        adj[5].Add(2);                 /* maxCount will have diameter of tree */        Console.WriteLine("Diameter of the given " +                     "tree is " + diameter(adj, n));    }} // This code is contributed by PrinciRaj1992
<script> // JavaScript program to find diameter of a// binary tree using DFS.         // Used to track farthest node.    let x;    let maxCount;    let adj=[];         // Sets maxCount as maximum distance    // from node    function dfsUtil(node,count,visited,adj)    {        visited[node] = true;        count++;                  let l = adj[node];        for(let i=0;i<l.length;i++)        {            if(!visited[l[i]]){                if (count >= maxCount) {                    maxCount = count;                    x = l[i];                }                dfsUtil(l[i], count, visited, adj);            }        }    }         // The function to do DFS traversal. It uses    // recursive dfsUtil()    function dfs(node,n,adj)    {        let visited = new Array(n + 1);        let count = 0;               // Mark all the vertices as not visited        for(let i=0;i<visited.length;i++)        {            visited[i]=false;        }               // Increment count by 1 for visited node        dfsUtil(node, count + 1, visited, adj);    }         // Returns diameter of binary tree represented    // as adjacency list.    function diameter(adj,n)    {        maxCount = Number.MIN_VALUE;               /* DFS from a random node and then see        farthest node X from it*/        dfs(1, n, adj);               /* DFS from X and check the farthest node        from it */        dfs(x, n, adj);               return maxCount;    }         /* Driver program to test above functions*/    let n = 5;    /* Constructed tree is             1            / \            2    3           / \          4   5 */        adj = new Array(n + 1);        for(let i = 0; i < n+1 ; i++)            adj[i] = [];               /*create undirected edges */        adj[1].push(2);        adj[2].push(1);        adj[1].push(3);        adj[3].push(1);        adj[2].push(4);        adj[4].push(2);        adj[2].push(5);        adj[5].push(2);                  /* maxCount will have diameter of tree */        document.write("Diameter of the given " +                       "tree is " + diameter(adj, n));       // This code is contributed by unknown2108 </script>
Output:  
Diameter of the given tree is 4
Time Complexity: O(n), where n is the number of nodes
Auxiliary Space: O(n)This article is contributed by Ankur Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
princiraj1992
mohit kumar 29
unknown2108
rohitmishra051000
Amazon
Cadence India
DFS
Directi
MakeMyTrip
Microsoft
Oracle
OYO Rooms
Philips
Salesforce
Snapdeal
VMWare
Tree
VMWare
Amazon
Microsoft
OYO Rooms
Snapdeal
MakeMyTrip
Oracle
Directi
Philips
Salesforce
Cadence India
DFS
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.