N-ary Tree Level Order Traversal - Practice Coding Problems

N-ary Tree Level Order Traversal - Problem

N-ary Tree Level Order Traversal challenges you to traverse a tree with potentially many children per node, level by level from left to right.

Given an n-ary tree (where each node can have any number of children), return the level order traversal of its nodes' values. This means you should visit all nodes at depth 0, then all nodes at depth 1, then depth 2, and so on.

For example, if you have a tree where the root has value 1 and three children with values [3, 2, 4], and node 3 has children [5, 6], your output should be [[1], [3, 2, 4], [5, 6]] - each inner array represents one level of the tree.

The key insight is that unlike binary trees, each node can have any number of children, making this a perfect application of breadth-first search (BFS).

Input & Output

example_1.py — Basic N-ary Tree

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

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

💡 Note: The tree has root 1 with children [3,2,4]. Node 3 has children [5,6]. Level order gives us: Level 0: [1], Level 1: [3,2,4], Level 2: [5,6]

example_2.py — 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: A more complex tree with 5 levels. Each level is processed in order from left to right, demonstrating the breadth-first nature of level order traversal.

example_3.py — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Edge case with only root node. The result is a single level containing just the root value.

Constraints

The height of the n-ary tree is less than or equal to 1000
The total number of nodes is between [0, 10⁴]
Node values are between [-100, 100]
Follow-up: Recursive solution is trivial, could you do it iteratively?

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Place the CEO (root) in your queue - they're the only person on the top floor

Process Current Floor

Interview everyone currently in your queue (one complete floor)

Add Next Floor

Each person tells you about their direct reports - add all these to the queue

Repeat Floors

Continue until you've surveyed every floor in the building

Key Takeaway

🎯 Key Insight: BFS with a queue naturally processes nodes level-by-level by keeping track of how many nodes belong to the current level, ensuring perfect level-order grouping!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses Breadth-First Search (BFS) with a queue. For each level, we process exactly the number of nodes currently in the queue, ensuring proper level grouping. This approach has O(n) time complexity and is the most natural way to implement level-order traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Breadth-First Search (Queue) - Optimal	O(n)	O(w + n)	Use a queue to process nodes level by level in true breadth-first order
Brute Force (Recursive DFS with Level Tracking)	O(n)	O(h + n)	Use depth-first search with level parameter to manually track and group nodes by level

Breadth-First Search (Queue) - Optimal — Algorithm Steps

Initialize a queue with the root node
While queue is not empty, process current level
Record the queue size (number of nodes in current level)
Process exactly that many nodes, adding their values to current level
Add all children of processed nodes to queue for next level
Add completed level to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node in queue

Process Level

Process all nodes currently in queue (one complete level)

Add Children

Add all children of processed nodes to queue

Repeat

Continue until queue is empty

Code -

solution.c — C

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

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

struct QueueNode {
    struct Node* node;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
    int size;
};

struct Queue* createQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    q->size = 0;
    return q;
}

void enqueue(struct Queue* q, struct Node* node) {
    struct QueueNode* temp = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    temp->node = node;
    temp->next = NULL;
    if (q->rear == NULL) {
        q->front = q->rear = temp;
    } else {
        q->rear->next = temp;
        q->rear = temp;
    }
    q->size++;
}

struct Node* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    struct QueueNode* temp = q->front;
    struct Node* node = temp->node;
    q->front = q->front->next;
    if (q->front == NULL) q->rear = NULL;
    free(temp);
    q->size--;
    return node;
}

int** levelOrder(struct Node* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int** result = (int**)malloc(1000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    struct Queue* queue = createQueue();
    enqueue(queue, root);
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        result[*returnSize] = (int*)malloc(1000 * sizeof(int));
        returnColumnSizes[*returnSize] = 0;
        
        // Process all nodes in current level
        for (int i = 0; i < levelSize; i++) {
            struct Node* node = dequeue(queue);
            result[*returnSize][returnColumnSizes[*returnSize]++] = node->val;
            
            // Add all children to queue for next level
            for (int j = 0; j < node->numChildren; j++) {
                enqueue(queue, node->children[j]);
            }
        }
        
        (*returnSize)++;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once

✓ Linear Growth

Space Complexity

O(w + n)

O(w) for queue where w is maximum width of tree, O(n) for result storage

⚡ Linearithmic Space

89.2K 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 (Queue) - Optimal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler