N-ary Tree Postorder Traversal

N-ary Tree Postorder Traversal - Problem

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

N-ary tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (see examples).

In postorder traversal, we visit all children nodes first, then the parent node.

Input & Output

Example 1 — Basic N-ary Tree

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

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

💡 Note: Postorder visits children first: node 3's children [5,6], then node 3, then nodes 2,4, finally root 1

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

💡 Note: Complex tree with multiple levels - each subtree processed before its parent

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Single node tree returns just that 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

Visualization

Tap to expand

Asked in

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

The key insight is that postorder traversal visits children before the parent node. The recursive DFS approach naturally follows this pattern by processing all children recursively before adding the current node to the result. Time: O(n), Space: O(n) for recursion stack and result array.

Common Approaches

✓ Iterative with Stack

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

Use two stacks: one for traversal and one for result ordering. Process nodes iteratively to avoid recursion stack limitations.

Recursive DFS

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

Use the natural recursive structure of trees. For each node, recursively traverse all its children first, then add the current node's value to the result.

Iterative with Stack — Algorithm Steps

Push root to stack
Pop node, add to result stack, push children to traversal stack
Pop from result stack to get postorder

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Root

Add root node 1 to stack

Process & Push Children

Pop node, add to result, push children

Reverse Result

Reverse final array for postorder

Code -

solution.c — C

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

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

struct Node** stack;
int stackSize;
int* result;
int resultSize;
struct Node** queue;
int queueHead, queueTail;

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

void parseTokens(const char* str, char tokens[][20], int* tokenCount) {
    *tokenCount = 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 != ' ') {
            tokens[*tokenCount][i++] = *p++;
        }
        tokens[*tokenCount][i] = '\0';
        (*tokenCount)++;
    }
}

struct Node* buildTree(char* input) {
    if (strcmp(input, "[]") == 0 || strlen(input) == 0) return NULL;
    
    char tokens[10000][20];
    int tokenCount;
    parseTokens(input, tokens, &tokenCount);
    
    if (tokenCount == 0 || strcmp(tokens[0], "null") == 0) return NULL;
    
    struct Node* root = createNode(atoi(tokens[0]));
    queue = (struct Node**)malloc(10000 * sizeof(struct Node*));
    queueHead = 0;
    queueTail = 0;
    
    queue[queueTail++] = root;
    
    int i = 2; // Start after root and first null
    while (queueHead < queueTail && i < tokenCount) {
        struct Node* node = queue[queueHead++];
        
        // Count children first
        int childCount = 0;
        int j = i;
        while (j < tokenCount && strcmp(tokens[j], "null") != 0) {
            childCount++;
            j++;
        }
        
        if (childCount > 0) {
            node->children = (struct Node**)malloc(childCount * sizeof(struct Node*));
            node->numChildren = childCount;
            
            int childIndex = 0;
            while (i < tokenCount && strcmp(tokens[i], "null") != 0) {
                struct Node* child = createNode(atoi(tokens[i]));
                node->children[childIndex++] = child;
                queue[queueTail++] = child;
                i++;
            }
        }
        i++; // Skip null separator
    }
    
    free(queue);
    return root;
}

int* solution(struct Node* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    stack = (struct Node**)malloc(10000 * sizeof(struct Node*));
    result = (int*)malloc(10000 * sizeof(int));
    stackSize = 0;
    resultSize = 0;
    
    stack[stackSize++] = root;
    
    while (stackSize > 0) {
        struct Node* node = stack[--stackSize];
        result[resultSize++] = node->val;
        
        // Add children to stack (left to right for postorder)
        for (int i = 0; i < node->numChildren; i++) {
            stack[stackSize++] = node->children[i];
        }
    }
    
    // Reverse to get postorder (children before parent)
    for (int i = 0; i < resultSize / 2; i++) {
        int temp = result[i];
        result[i] = result[resultSize - 1 - i];
        result[resultSize - 1 - i] = temp;
    }
    
    free(stack);
    *returnSize = resultSize;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline if present
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
    }
    
    struct Node* root = buildTree(line);
    
    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(n)

Two stacks can hold up to n nodes total

⚡ Linearithmic Space

186.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 with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler