Diameter of N-Ary Tree

Diameter of N-Ary Tree - Problem

Given a root of an N-ary tree, you need to compute the length of the diameter of the tree.

The diameter of an N-ary tree is the length of the longest path between any two nodes in the tree. This path may or may not pass through the root.

Note: The length of a path between two nodes is represented by the number of edges between them.

Input & Output

Example 1 — Standard N-ary Tree

$ Input: root = [1,null,3,2,4,null,5,6]

› Output: 3

💡 Note: The longest path is from node 5 → 3 → 1 → 2, which has 3 edges. The diameter passes through the root node 1.

Example 2 — Single Node

$ Input: root = [1]

› Output: 0

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

Example 3 — Linear Tree

$ Input: root = [1,null,2,null,3,null,4]

› Output: 3

💡 Note: The tree forms a linear chain: 1 → 2 → 3 → 4. The diameter is the path from 1 to 4, which has 3 edges.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 F Facebook 38 A Amazon 32 M Microsoft 28

The optimal approach uses DFS to calculate subtree heights while tracking the maximum diameter. For each node, the diameter passing through it equals the sum of its two deepest child subtree heights. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Brute Force - Check All Paths

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

Calculate the distance between every pair of nodes in the tree and return the maximum distance found. This involves exploring all possible paths.

DFS with Height Calculation

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

Use DFS to calculate the height of each subtree. For each node, the diameter passing through it is the sum of its two deepest subtree heights. Track the global maximum.

Brute Force - Check All Paths — Algorithm Steps

For each node, perform DFS to find distances to all other nodes
Track the maximum distance found across all pairs
Return the global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Nodes

Gather all nodes in the tree

Check Pairs

Calculate distance between each pair

Find Maximum

Track the longest distance found

Code -

solution.c — C

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

struct Node {
    int val;
    struct Node** children;
    int childCount;
};

struct Node* createNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->children = NULL;
    node->childCount = 0;
    return node;
}

void getAllNodes(struct Node* node, struct Node** nodes, int* count) {
    if (!node) return;
    
    nodes[(*count)++] = node;
    for (int i = 0; i < node->childCount; i++) {
        getAllNodes(node->children[i], nodes, count);
    }
}

int bfsDistance(struct Node* start, struct Node* target, struct Node** allNodes, int nodeCount) {
    if (start == target) return 0;
    
    // Build adjacency map
    struct Node* adj[1000][100]; // adj[i] contains neighbors of allNodes[i]
    int adjCount[1000] = {0};
    
    for (int i = 0; i < nodeCount; i++) {
        struct Node* node = allNodes[i];
        for (int j = 0; j < node->childCount; j++) {
            struct Node* child = node->children[j];
            // Find indices
            int nodeIdx = -1, childIdx = -1;
            for (int k = 0; k < nodeCount; k++) {
                if (allNodes[k] == node) nodeIdx = k;
                if (allNodes[k] == child) childIdx = k;
            }
            if (nodeIdx != -1 && childIdx != -1) {
                adj[nodeIdx][adjCount[nodeIdx]++] = child;
                adj[childIdx][adjCount[childIdx]++] = node;
            }
        }
    }
    
    struct Node* queue[1000];
    int distances[1000];
    int visited[1000] = {0};
    int front = 0, rear = 0;
    
    queue[rear] = start;
    distances[rear] = 0;
    rear++;
    
    // Mark start as visited
    for (int i = 0; i < nodeCount; i++) {
        if (allNodes[i] == start) {
            visited[i] = 1;
            break;
        }
    }
    
    while (front < rear) {
        struct Node* node = queue[front];
        int dist = distances[front];
        front++;
        
        int nodeIdx = -1;
        for (int i = 0; i < nodeCount; i++) {
            if (allNodes[i] == node) {
                nodeIdx = i;
                break;
            }
        }
        
        if (nodeIdx == -1) continue;
        
        for (int i = 0; i < adjCount[nodeIdx]; i++) {
            struct Node* neighbor = adj[nodeIdx][i];
            if (neighbor == target) {
                return dist + 1;
            }
            
            int neighborIdx = -1;
            for (int j = 0; j < nodeCount; j++) {
                if (allNodes[j] == neighbor) {
                    neighborIdx = j;
                    break;
                }
            }
            
            if (neighborIdx != -1 && !visited[neighborIdx]) {
                visited[neighborIdx] = 1;
                queue[rear] = neighbor;
                distances[rear] = dist + 1;
                rear++;
            }
        }
    }
    
    return -1;
}

int solution(struct Node* root) {
    if (!root) return 0;
    
    struct Node* allNodes[1000];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    int maxDiameter = 0;
    for (int i = 0; i < nodeCount; i++) {
        for (int j = i + 1; j < nodeCount; j++) {
            int distance = bfsDistance(allNodes[i], allNodes[j], allNodes, nodeCount);
            if (distance != -1) {
                if (distance > maxDiameter) {
                    maxDiameter = distance;
                }
            }
        }
    }
    
    return maxDiameter;
}

struct Node* buildTree(int* nodes, int nodeCount) {
    if (nodeCount == 0 || nodes[0] == -999) return NULL;
    
    // Create all node objects first
    struct Node* nodeObjects[1000] = {NULL};
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i] != -999) {
            nodeObjects[i] = createNode(nodes[i]);
        }
    }
    
    struct Node* root = nodeObjects[0];
    if (nodeCount <= 1) return root;
    
    // Use queue for BFS level-by-level construction
    struct Node* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    // Skip first null if present
    if (i < nodeCount && nodes[i] == -999) {
        i++;
    }
    
    while (front < rear && i < nodeCount) {
        struct Node* current = queue[front++];
        if (current == NULL) continue;
        
        // Collect all children for current node until next null
        int childStart = i;
        while (i < nodeCount && nodes[i] != -999) {
            i++;
        }
        int childCount = i - childStart;
        
        if (childCount > 0) {
            current->children = (struct Node**)malloc(childCount * sizeof(struct Node*));
            current->childCount = childCount;
            
            for (int j = 0; j < childCount; j++) {
                current->children[j] = nodeObjects[childStart + j];
                if (nodeObjects[childStart + j] != NULL) {
                    queue[rear++] = nodeObjects[childStart + j];
                }
            }
        }
        
        // Skip the null separator
        if (i < nodeCount && nodes[i] == -999) {
            i++;
        }
    }
    
    return root;
}

static int parseInput(const char* input, int* values) {
    int count = 0;
    const char* p = input;
    
    // Skip to '['
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip '['
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == '\t' || *p == ',')) p++;
        
        if (*p == ']' || !*p) break;
        
        if (*p == 'n') { // "null"
            values[count++] = -999; // Use -999 as null marker
            while (*p && *p != ',' && *p != ']') p++;
        } else if (isdigit(*p) || *p == '-') {
            char* end;
            values[count++] = (int)strtol(p, &end, 10);
            p = end;
        } else {
            p++;
        }
    }
    
    return count;
}

int main() {
    static char input[2000];
    if (!fgets(input, sizeof(input), stdin)) {
        return 1;
    }
    
    input[strcspn(input, "\n")] = '\0';
    
    static int values[1000];
    int count = parseInput(input, values);
    
    struct Node* root = buildTree(values, count);
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse the entire tree to find distances

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

89.4K Views

Medium Frequency

~25 min Avg. Time

1.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 - Check All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler