Maximum Depth of N-ary Tree - Practice Coding Problems

Maximum Depth of N-ary Tree - Problem

Imagine you're exploring a complex family tree where each person can have any number of children (not just two). Your mission is to find the deepest generation in this family lineage.

Given an N-ary tree (where each node can have 0 to N children), determine its maximum depth. The maximum depth represents the number of nodes along the longest path from the root node down to the farthest leaf node.

Key Points:

The root node is at depth 1 (not 0)
Each level down adds 1 to the depth
A leaf node has no children
We need to find the path with the most nodes from root to any leaf

Input: Root of an N-ary tree
Output: Integer representing the maximum depth

Input & Output

example_1.py — Basic N-ary Tree

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

› Output: 3

💡 Note: The tree has root 1 with children [3,2,4]. Node 3 has children [5,6]. The longest path is 1→3→5 (or 1→3→6), giving us a depth of 3 nodes.

example_2.py — Complex N-ary 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]

› Output: 5

💡 Note: This tree has multiple levels. The deepest path goes through 5 levels: root→child→grandchild→great-grandchild→great-great-grandchild, resulting in a maximum depth of 5.

example_3.py — Single Node Tree

$ Input: root = [1]

› Output: 1

💡 Note: A tree with only the root node has a depth of 1, since the root itself counts as one level.

Constraints

The total number of nodes is in the range [0, 10⁴]
The depth of the n-ary tree will not exceed 1000
Node values are unique

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the root node (entrance of building) with depth 1

Explore All Children

For each child node, recursively find its maximum depth

Combine Results

Take the maximum depth among all children and add 1 for current level

Return Maximum

The recursion naturally returns the overall maximum depth

Key Takeaway

🎯 Key Insight: The maximum depth of an N-ary tree is found by recursively computing the maximum depth of all subtrees and adding 1. This elegant recursive solution mirrors the tree's natural structure and achieves optimal O(n) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses recursive depth-first search (DFS) to traverse the N-ary tree. For each node, we find the maximum depth among all its children and add 1 for the current node. This approach visits each node exactly once, achieving O(n) time complexity and O(h) space complexity where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Breadth-First Search (BFS) - Level Order	O(n)	O(w)	Use queue to traverse level by level, counting depth as we go
Depth-First Search (DFS) - Optimal	O(n)	O(h)	Recursively traverse tree, tracking maximum depth in single pass
Naive Approach (For each node, count depth)	O(n²)	O(h)	For each node, traverse back to root to count depth, then find maximum

Breadth-First Search (BFS) - Level Order — Algorithm Steps

Use a queue to store nodes with their corresponding depths
Start by adding root with depth 1 to queue
While queue is not empty, process current level
For each node, add all its children to queue with depth+1
Track the maximum depth seen during traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize queue

Add root node with depth 1 to queue

Process level by level

For each node, add all children with incremented depth

Track maximum depth

Keep track of the highest depth encountered

Code -

solution.c — C

// BFS Level-order solution
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    struct Node* node;
    int depth;
} QueueItem;

int maxDepth(struct Node* root) {
    if (root == NULL) {
        return 0;
    }
    
    QueueItem queue[10000];
    int front = 0, rear = 0;
    
    queue[rear++] = (QueueItem){root, 1};
    int maxDepth = 0;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        if (current.depth > maxDepth) {
            maxDepth = current.depth;
        }
        
        for (int i = 0; i < current.node->numChildren; i++) {
            queue[rear++] = (QueueItem){current.node->children[i], current.depth + 1};
        }
    }
    
    return maxDepth;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in level-order traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree

✓ Linear Space

89.6K Views

High Frequency

~15 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

Breadth-First Search (BFS) - Level Order — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler