Diameter of N-Ary Tree - Practice Coding Problems

Diameter of N-Ary Tree - Problem

🌳 Find the Diameter of an N-Ary Tree

Given the root of an N-ary tree, you need to find the diameter - the length of the longest path between any two nodes in the tree. This path may or may not pass through the root.

What makes this challenging? Unlike binary trees where each node has at most 2 children, N-ary trees can have any number of children. The longest path could wind through multiple levels and branches.

Key Points:

The diameter is measured in number of edges, not nodes
The longest path might be between two leaf nodes deep in different subtrees
We need to consider all possible paths, not just those through the root

Input: Root of an N-ary tree (level-order serialization with null separators)
Output: Integer representing the diameter (longest path length)

Input & Output

example_1.py — Simple N-ary Tree

$ Input: root = [1,null,2,3,null,5,6]\nTree structure:\n 1\n / \\\n 2 3\n / \\\n5 6

› Output: 3

💡 Note: The longest path is between nodes 5→2→6 or 5→2→1→3, both with length 3 edges.

example_2.py — Larger Tree

$ Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\nTree with multiple levels and branches

› Output: 7

💡 Note: The diameter passes through several nodes connecting the deepest leaves on opposite sides of the tree.

example_3.py — Single Node

$ Input: root = [1]\nTree with only one node

› Output: 0

💡 Note: A single node has no edges, so the diameter is 0.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-100 <= Node.val <= 100
The depth of the n-ary tree is less than or equal to 1000
Each node can have any number of children (including 0)

Visualization

Tap to expand

Understanding the Visualization

Understand the Problem

The diameter is the longest path between any two nodes, measured in edges

Key Insight

The longest path through any node equals the sum of its two longest descending paths

DFS Approach

Use post-order DFS to calculate child heights before processing parent

Track Maximum

Keep track of maximum diameter found across all nodes during traversal

Key Takeaway

🎯 Key Insight: The diameter of an N-ary tree can be found in O(n) time using a single DFS traversal, where we calculate the two longest paths from each node to its descendants.

Asked in

G Google 45 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a single DFS traversal with post-order processing. For each node, we calculate the heights of all child subtrees, find the two tallest subtrees, and compute the diameter through that node as tallest + second_tallest + 2. This achieves O(n) time complexity by visiting each node exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Single DFS (Optimal)	O(n)	O(h)	Calculate diameter in one DFS pass using post-order traversal
Brute Force (DFS from Every Node)	O(n²)	O(h)	Calculate longest path from every node to every other node

Single DFS (Optimal) — Algorithm Steps

Start DFS from root in post-order fashion
For each node, recursively get heights of all child subtrees
Find the two tallest child subtrees
Calculate diameter through current node: tallest + second_tallest + 2
Update global maximum diameter
Return height of current subtree to parent

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Leaves First

DFS visits leaf nodes, returns height = 1

Calculate at Internal Node

For each internal node, get child heights and find two tallest

Update Diameter

Diameter through node = tallest + second_tallest + 2

Return Height

Return height of current subtree to parent

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node** children;
    int numChildren;
} Node;

static int maxDiameter = 0;

int compare(const void* a, const void* b) {
    return (*(int*)b) - (*(int*)a);  // Descending order
}

int dfs(Node* node) {
    if (!node) return 0;
    
    // Get heights of all child subtrees
    int* childHeights = (int*)malloc(node->numChildren * sizeof(int));
    for (int i = 0; i < node->numChildren; i++) {
        childHeights[i] = dfs(node->children[i]);
    }
    
    // Sort to get the two tallest subtrees
    qsort(childHeights, node->numChildren, sizeof(int), compare);
    
    // Calculate diameter through this node
    int diameterThroughNode = 0;
    if (node->numChildren >= 2) {
        diameterThroughNode = childHeights[0] + childHeights[1] + 2;
    } else if (node->numChildren == 1) {
        diameterThroughNode = childHeights[0] + 1;
    }
    
    // Update global maximum
    if (diameterThroughNode > maxDiameter) {
        maxDiameter = diameterThroughNode;
    }
    
    // Return height of current subtree
    int result = 1;
    if (node->numChildren > 0) {
        result = childHeights[0] + 1;
    }
    
    free(childHeights);
    return result;
}

int diameter(Node* root) {
    if (!root) return 0;
    
    maxDiameter = 0;
    dfs(root);
    return maxDiameter;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once, with constant work per node

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(n) worst case for skewed tree

✓ Linear Space

42.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

🌳 Find the Diameter of an N-Ary Tree

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler