N-ary Tree Preorder Traversal

N-ary Tree Preorder Traversal - Problem

Given the root of an n-ary tree, return the preorder 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).

Preorder traversal visits nodes in the order: current node → left subtree → right subtree (for binary trees), or current node → all children from left to right (for n-ary trees).

Input & Output

Example 1 — Basic N-ary Tree

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

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

💡 Note: Start at root 1, then visit child 3 and its children 5,6, then visit remaining children 2,4 of root

Example 2 — Complex 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: Preorder traversal visits each node before exploring its subtree

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Tree with only root node returns array with single element

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

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 22 f Facebook 18

N-ary tree preorder traversal visits nodes in root-first order. The key insight is processing the current node before its children. Both recursive DFS and iterative stack approaches work optimally. Time: O(n), Space: O(h) for recursion or O(w) for stack where h is height and w is maximum width.

Common Approaches

✓ Iterative Stack

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

Replace the recursive call stack with an explicit stack data structure. Push children in reverse order so they're processed left to right when popped.

Recursive DFS

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

Visit the current node, add its value to result, then recursively traverse all children from left to right. This directly follows the definition of preorder traversal.

Iterative Stack — Algorithm Steps

Push root to stack
While stack not empty: pop node, add to result, push children in reverse order

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Root

Start with root 1 in stack

Pop and Process

Pop 1, add to result, push children 4,2,3 (reverse order)

Continue

Pop 3, add to result, push children 6,5

Code -

solution.c — C

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

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

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

void parseArray(const char* str, int* arr, int* size, int* isNull) {
    *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;
        
        if (*p == 'n') { // null
            isNull[*size] = 1;
            arr[(*size)++] = 0;
            while (*p && *p != ',' && *p != ']') p++;
        } else {
            isNull[*size] = 0;
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        }
    }
}

struct Node* buildTree(int* arr, int* isNull, int arrSize) {
    if (arrSize == 0 || isNull[0]) {
        return NULL;
    }
    
    struct Node* root = createNode(arr[0]);
    struct Node** queue = (struct Node**)malloc(10000 * sizeof(struct Node*));
    int queueStart = 0, queueEnd = 1;
    queue[0] = root;
    int i = 2; // Skip root and first null
    
    while (queueStart < queueEnd && i < arrSize) {
        struct Node* node = queue[queueStart++];
        struct Node** children = (struct Node**)malloc(1000 * sizeof(struct Node*));
        int numChildren = 0;
        
        while (i < arrSize && !isNull[i]) {
            struct Node* child = createNode(arr[i]);
            children[numChildren++] = child;
            queue[queueEnd++] = child;
            i++;
        }
        
        if (numChildren > 0) {
            node->children = (struct Node**)malloc(numChildren * sizeof(struct Node*));
            for (int j = 0; j < numChildren; j++) {
                node->children[j] = children[j];
            }
            node->numChildren = numChildren;
        }
        free(children);
        i++; // Skip the null separator
    }
    
    free(queue);
    return root;
}

int* solution(struct Node* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(10000 * sizeof(int));
    struct Node** stack = (struct Node**)malloc(10000 * sizeof(struct Node*));
    int stackSize = 0;
    *returnSize = 0;
    
    stack[stackSize++] = root;
    
    while (stackSize > 0) {
        struct Node* node = stack[--stackSize];
        result[(*returnSize)++] = node->val;
        
        // Add children in reverse order so they're processed left to right
        for (int i = node->numChildren - 1; i >= 0; i--) {
            stack[stackSize++] = node->children[i];
        }
    }
    
    free(stack);
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int arr[10000];
    int isNull[10000];
    int arrSize;
    parseArray(line, arr, &arrSize, isNull);
    
    struct Node* root = buildTree(arr, isNull, arrSize);
    
    int returnSize;
    int* result = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once

✓ Linear Growth

Space Complexity

O(w)

Stack holds at most w nodes where w is maximum width of tree

✓ Linear Space

182.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler