N-ary Tree Preorder Traversal - Practice Coding Problems

N-ary Tree Preorder Traversal - Problem

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

In preorder traversal, we visit nodes in this order:

Visit the current node (process its value)
Recursively visit all children from left to right

An n-ary tree is a tree where each node can have any number of children (0 to n), unlike binary trees which have at most 2 children.

Input Format: The tree is represented using level order traversal where each group of children is separated by null values.

Goal: Return a list containing all node values in preorder sequence.

Input & Output

example_1.py — Simple N-ary Tree

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

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

💡 Note: Starting at root 1, we visit it first. Then we visit its children 3,2,4 in order. For node 3, we first visit 3 itself, then its children 5,6. Finally we visit nodes 2 and 4 (which have no children).

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,6,7,11,14,4,8,12,5,9,13,10]

💡 Note: This demonstrates preorder traversal on a more complex tree with multiple levels. We always visit parent nodes before their children, going depth-first from left to right.

example_3.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Edge case with just one node. The preorder traversal simply returns that single node's value.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
0 ≤ Node.val ≤ 10⁴
The height of the n-ary tree is less than or equal to 1000
Follow up: Recursive solution is trivial, could you do it iteratively?

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the root node and add its value to the result immediately

Visit Children Left-to-Right

Process each child recursively in order from left to right

Depth-First Pattern

For each child, complete its entire subtree before moving to the next sibling

Build Result

The final result contains all nodes in preorder: parent before children

Key Takeaway

🎯 Key Insight: Preorder traversal naturally follows parent-child relationships - we always process a node before exploring its descendants. Both recursive and iterative solutions are optimal with O(n) time complexity, visiting each node exactly once.

Asked in

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

The optimal approach uses either recursion (natural and clean) or an iterative stack (avoids stack overflow). Both achieve O(n) time complexity by visiting each node exactly once. The key insight is that preorder traversal follows the pattern: visit current node, then recursively visit all children left-to-right. For the iterative approach, pushing children in reverse order ensures correct left-to-right processing when popped from the stack.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Stack Approach (Optimal)	O(n)	O(w)	Use an explicit stack to simulate recursion and control memory usage
Recursive Approach (Natural Solution)	O(n)	O(h)	Use recursion to naturally follow the preorder traversal pattern

Iterative Stack Approach (Optimal) — Algorithm Steps

Initialize empty result list and stack with root node
While stack is not empty, pop current node
Add current node's value to result
Push all children to stack in reverse order (right to left)
Continue until stack is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Stack: [1], Result: []

Process Node 1

Pop 1, add to result. Push children [4,2,3]. Stack: [4,2,3]

Process Node 3

Pop 3, add to result. Push children [6,5]. Stack: [4,2,6,5]

Continue

Process remaining: 5,6,2,4. Final: [1,3,5,6,2,4]

Code -

solution.c — C

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

// Definition for a Node
struct Node {
    int val;
    int numChildren;
    struct Node** children;
};

// Stack implementation
struct Stack {
    struct Node** items;
    int top;
    int capacity;
};

struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->items = (struct Node**)malloc(capacity * sizeof(struct Node*));
    return stack;
}

void push(struct Stack* stack, struct Node* item) {
    stack->items[++stack->top] = item;
}

struct Node* pop(struct Stack* stack) {
    return stack->items[stack->top--];
}

int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

int* preorder(struct Node* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int* result = (int*)malloc(10000 * sizeof(int));
    struct Stack* stack = createStack(10000);
    push(stack, root);
    
    while (!isEmpty(stack)) {
        // Pop current node
        struct Node* node = pop(stack);
        
        // Visit current node
        result[(*returnSize)++] = node->val;
        
        // Push children in reverse order
        for (int i = node->numChildren - 1; i >= 0; i--) {
            push(stack, node->children[i]);
        }
    }
    
    free(stack->items);
    free(stack);
    return result;
}

int main() {
    int returnSize;
    int* result = preorder(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, where n is the total number of nodes

✓ Linear Growth

Space Complexity

O(w)

Stack space proportional to maximum width w of the tree, plus O(n) for result

✓ Linear Space

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

Iterative Stack Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler