Tree Diameter

Tree Diameter - Problem

Tree Depth-First Search Breadth-First Search Graph Topological Sort Medium

The diameter of a tree is the number of edges in the longest path in that tree. There is an undirected tree of n nodes labeled from 0 to n - 1.

You are given a 2D array edges where edges.length == n - 1 and edges[i] = [ai, bi] indicates that there is an undirected edge between nodes ai and bi in the tree.

Return the diameter of the tree.

Input & Output

Example 1 — Linear Tree

$ Input: edges = [[0,1],[1,2],[2,3],[1,4]]

› Output: 3

💡 Note: The tree forms a shape where longest path is from node 4 to node 3 (or 3 to 4), going through nodes 4→1→2→3, which has 3 edges.

Example 2 — Simple Path

$ Input: edges = [[0,1],[0,2]]

› Output: 2

💡 Note: Tree with 3 nodes: 1-0-2. The diameter is the path from node 1 to node 2, which has 2 edges (1→0→2).

Example 3 — Single Edge

$ Input: edges = [[0,1]]

› Output: 1

💡 Note: Tree with only 2 nodes connected by 1 edge. The diameter is simply that one edge.

Constraints

n == edges.length + 1
1 ≤ n ≤ 10⁴
0 ≤ a_i, b_i < n
a_i ≠ b_i
The given input represents a valid tree.

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 G Google 8 M Microsoft 6

The key insight is that the longest path in a tree always connects two leaf nodes, and we can find it efficiently using two DFS/BFS traversals. The optimal approach runs DFS from any node to find one endpoint, then DFS from that endpoint to find the diameter. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - DFS from Every Node

⏱️ Time: O(n²) Space: O(n)

For each node in the tree, perform a DFS to find the maximum distance to any other node. The diameter is the maximum distance found across all starting nodes.

Two BFS - Level-Order Approach

⏱️ Time: O(n) Space: O(n)

Similar to two DFS approach but using BFS (breadth-first search). First BFS finds one endpoint of the diameter, second BFS from that endpoint finds the actual diameter length.

Two DFS - Optimal Tree Diameter

⏱️ Time: O(n) Space: O(n)

Use two DFS traversals: first from any node to find one end of the diameter, then from that end to find the other end. The distance in the second DFS is the diameter.

Brute Force - DFS from Every Node — Algorithm Steps

Build adjacency list from edges
For each node, run DFS to find max distance
Track the overall maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

DFS from Each Node

Run DFS from every node to find max distance

Track Maximum

Keep track of the overall maximum distance

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_NODES 10000
#define MAX_QUEUE 20000

int graph[MAX_NODES][MAX_NODES];
int graph_size[MAX_NODES];

typedef struct {
    int node;
    int dist;
} QueueItem;

typedef struct {
    int farthest_node;
    int max_distance;
} BFSResult;

BFSResult bfsFarthest(int start) {
    bool visited[MAX_NODES] = {false};
    QueueItem queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (QueueItem){start, 0};
    visited[start] = true;
    int farthestNode = start;
    int maxDistance = 0;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        int node = current.node;
        int dist = current.dist;
        
        if (dist > maxDistance) {
            maxDistance = dist;
            farthestNode = node;
        }
        
        for (int i = 0; i < graph_size[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                queue[rear++] = (QueueItem){neighbor, dist + 1};
            }
        }
    }
    
    return (BFSResult){farthestNode, maxDistance};
}

int solution(int edges[][2], int edgesSize) {
    if (edgesSize == 0) {
        return 0;
    }
    
    // Initialize and build graph
    memset(graph_size, 0, sizeof(graph_size));
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graph_size[u]++] = v;
        graph[v][graph_size[v]++] = u;
    }
    
    // First BFS from node 0 to find one end of diameter
    BFSResult result1 = bfsFarthest(0);
    int farthestFrom0 = result1.farthest_node;
    
    // Second BFS from that farthest node to find actual diameter
    BFSResult result2 = bfsFarthest(farthestFrom0);
    int diameter = result2.max_distance;
    
    return diameter;
}

void parseArray(const char* str, int edges[][2], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        int u = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        int v = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ']') p++;
        
        edges[*size][0] = u;
        edges[*size][1] = v;
        (*size)++;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int edges[1000][2];
    int edgesSize = 0;
    
    parseArray(line, edges, &edgesSize);
    
    printf("%d\n", solution(edges, edgesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform DFS which visits all n nodes

✓ Linear Growth

Space Complexity

O(n)

Adjacency list storage and recursion stack depth up to n

⚡ Linearithmic Space

89.4K Views

Medium Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - DFS from Every Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler