Diameter of a tree using DFS
Last Updated :
07 Apr, 2025
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 post
Diameter of a binary tree
In 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.
Implementation:
C++
// 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>
OutputDiameter of the given tree is 4
Time Complexity: O(n), where n is the number of nodes
Auxiliary Space: O(n)
Similar Reads
Diameter of n-ary tree using BFS N-ary tree refers to the rooted tree in which each node having atmost k child nodes. The diameter of n-ary tree is the longest path between two leaf nodes. Various approaches have already been discussed to compute diameter of tree. Diameter of an N-ary tree Diameter of a Binary Tree in O(n) Diameter
7 min read
Diameter of an N-ary tree The diameter of an N-ary tree is the longest path present between any two nodes of the tree. These two nodes must be two leaf nodes. The following examples have the longest path[diameter] shaded. Example 1: Example 2: Prerequisite: Diameter of a binary tree. The path can either start from one of th
15+ min read
Diameter of a Binary Tree Given a binary tree, the task is to determine the diameter of the tree. The diameter/width of a tree is defined as the number of edges on the longest path between any two nodes. Examples:Input:Output: 2Explanation: The longest path has 2 edges (node 2 -> node 1 -> node 3).Input:Output: 4Explan
8 min read
Subtree of all nodes in a tree using DFS Given n nodes of a tree and their connections, print Subtree nodes of every node.Subtree of a node is defined as a tree which is a child of a node. The name emphasizes that everything which is a descendant of a tree node is a tree too, and is a subset of the larger tree. Examples : Input: N = 5 0 1
8 min read
Diameter of a Binary Tree using Top Down Recursion Given a binary tree, the task is to determine the diameter of the tree. The diameter/width of a tree is defined as the number of edges on the longest path between any two nodes. Examples:Input: Output: 2Explanation: The longest path has 2 edges (node 2 -> node 1 -> node 3). Input: Output: 4Exp
8 min read
CSES Solutions - Tree Diameter You are given a tree consisting of n nodes. The diameter of a tree is the maximum distance between two nodes. Your task is to determine the diameter of the tree. Examples: Input: n = 5, edges = { { 1, 2 }, { 1, 3 }, { 3, 4 }, { 3, 5 } };Output: 3 Input: n = 4, edges = { { 1, 2 }, { 1, 3 }, { 3, 4 }}
6 min read