N-ary Tree Level Order Traversal

N-ary Tree Level Order Traversal - Problem

Given the root of an n-ary tree, return the level order traversal of its nodes' values.

Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).

In level order traversal, we visit all nodes at depth 0, then all nodes at depth 1, then all nodes at depth 2, and so on. Within each level, nodes can be visited in any order.

Input & Output

Example 1 — Basic N-ary Tree

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

› Output: [[1],[3,2,4],[5,6]]

💡 Note: Level 0 contains root node 1. Level 1 contains its children 3, 2, 4. Level 2 contains children of node 3: nodes 5 and 6.

Example 2 — Deeper 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: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

💡 Note: Each level contains all nodes at that depth. The tree has 5 levels with varying numbers of nodes per level.

Example 3 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Tree with only root node results in single level containing just that node.

Constraints

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

Visualization

Tap to expand

Asked in

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

The optimal approach uses BFS with a queue to naturally process nodes level by level. The key insight is that a queue processes nodes in the exact order needed for level-order traversal. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ BFS Queue Traversal

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

Use breadth-first search with a queue to naturally process nodes level by level. Process all nodes at the current level before moving to the next level.

Recursive DFS with Level Tracking

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

Recursively traverse the tree using depth-first search, keeping track of the current level. Add nodes to the appropriate level in the result array based on their depth.

BFS Queue Traversal — Algorithm Steps

Add root to queue
While queue not empty, process all nodes at current level
Add children of current level nodes to queue for next level

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Add root to queue, start processing

Process Level

Process all nodes in current level, add their children

Next Level

Queue now contains next level nodes

Code -

solution.c — C

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

#define MAX_CHILDREN 1000
#define MAX_LEVELS 1000
#define MAX_NODES 10000

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

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

void dfs(struct Node* node, int level, int*** result, int** returnColumnSizes, int* returnSize) {
    if (!node) {
        return;
    }
    
    // Expand result if needed
    if (*returnSize <= level) {
        for (int i = *returnSize; i <= level; i++) {
            (*result)[i] = malloc(MAX_NODES * sizeof(int));
            (*returnColumnSizes)[i] = 0;
        }
        *returnSize = level + 1;
    }
    
    // FIX: Separated the comment from the assignment logic
    // Add current node to its level
    (*result)[level][(*returnColumnSizes)[level]] = node->val;
    (*returnColumnSizes)[level]++;
    
    // Visit all children at next level
    for (int i = 0; i < node->numChildren; i++) {
        dfs(node->children[i], level + 1, result, returnColumnSizes, returnSize);
    }
}

int** solution(struct Node* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int** result = malloc(MAX_LEVELS * sizeof(int*));
    *returnColumnSizes = malloc(MAX_LEVELS * sizeof(int));
    *returnSize = 0;
    
    dfs(root, 0, &result, returnColumnSizes, returnSize);
    return result;
}

// --- Parsing Helpers (Unchanged) ---

void parseArray(const char* str, char arr[][10], int* size) {
    *size = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int i = 0;
        while (*p && *p != ',' && *p != ']' && *p != ' ') {
            arr[*size][i++] = *p++;
        }
        arr[*size][i] = '\0';
        (*size)++;
    }
}

struct Node* buildTree(char arr[][10], int arrSize) {
    if (arrSize == 0 || strcmp(arr[0], "null") == 0) {
        return NULL;
    }
    
    struct Node* root = createNode(atoi(arr[0]));
    struct Node* queue[MAX_NODES];
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    int i = 2; 
    
    while (front < rear && i < arrSize) {
        struct Node* node = queue[front++];
        
        while (i < arrSize && strcmp(arr[i], "null") != 0) {
            struct Node* child = createNode(atoi(arr[i]));
            node->children[node->numChildren++] = child;
            queue[rear++] = child;
            i++;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[10000];
    // Use fgets to safely read input
    if (fgets(line, sizeof(line), stdin)) {
        char arr[1000][10];
        int arrSize;
        parseArray(line, arr, &arrSize);
        
        struct Node* root = buildTree(arr, arrSize);
        
        int returnSize;
        int* returnColumnSizes;
        int** result = solution(root, &returnSize, &returnColumnSizes);
        
        printf("[");
        for (int i = 0; i < returnSize; i++) {
            if (i > 0) printf(",");
            printf("[");
            for (int j = 0; j < returnColumnSizes[i]; j++) {
                if (j > 0) printf(",");
                printf("%d", result[i][j]);
            }
            printf("]");
        }
        printf("]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once

✓ Linear Growth

Space Complexity

O(w)

Queue stores maximum width w of tree at any level, plus O(n) for result

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

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

BFS Queue Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler