Maximum Depth of N-ary Tree

Maximum Depth of N-ary Tree - Problem

Given an n-ary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Note: Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value.

Input & Output

Example 1 — Standard N-ary Tree

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

› Output: 3

💡 Note: The tree has 3 levels: root (1) → children (3,2,4) → grandchildren (5,6). The maximum depth is 3.

Example 2 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Tree has only the root node, so maximum depth is 1.

Example 3 — Linear Tree

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

› Output: 4

💡 Note: Each node has one child forming a linear chain: 1→2→3→4, depth is 4.

Constraints

The total number of nodes is in the range [0, 10⁴]
The depth of the n-ary tree is less than or equal to 1000

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8 F Facebook 6

The key insight is that maximum depth equals 1 plus the maximum depth of any child subtree. Best approach is DFS recursion for its simplicity and clarity. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Breadth-First Search

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

Use a queue to process nodes level by level. Start with root in queue, then for each level, process all current nodes and add their children to queue. Count levels until queue is empty.

Brute Force DFS

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

Use depth-first search to visit every node, keeping track of current depth and updating maximum depth found. For each node, recursively find the depth of all children and take the maximum.

Optimized DFS

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

Improved DFS that handles base cases more efficiently. If a node has no children, immediately return 1. Otherwise, recursively compute depth of all children and return 1 plus the maximum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums1, int* nums2, int n) {
    int maxMatches = 0;
    
    // Try all possible right shifts (0 to n-1)
    for (int shifts = 0; shifts < n; shifts++) {
        int matches = 0;
        // Count matches without creating rotated array
        for (int i = 0; i < n; i++) {
            int originalPos = (i - shifts + n) % n;
            if (nums1[originalPos] == nums2[i]) {
                matches++;
            }
        }
        
        if (matches > maxMatches) {
            maxMatches = matches;
        }
    }
    
    return maxMatches;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse arrays (simple parsing for format [1,2,3])
    int nums1[100], nums2[100];
    int n = 0;
    
    // Skip the opening bracket and parse
    char* start1 = strchr(line1, '[');
    if (start1) start1++;
    char* token = strtok(start1, ",]");
    while (token != NULL) {
        nums1[n] = atoi(token);
        token = strtok(NULL, ",]");
        n++;
    }
    
    char* start2 = strchr(line2, '[');
    if (start2) start2++;
    token = strtok(start2, ",]");
    int i = 0;
    while (token != NULL) {
        nums2[i] = atoi(token);
        token = strtok(NULL, ",]");
        i++;
    }
    
    int result = solution(nums1, nums2, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

85.0K Views

Medium 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