Serialize and Deserialize N-ary Tree - Practice Coding Problems

Serialize and Deserialize N-ary Tree - Problem

Serialization is the process of converting a complex data structure into a format that can be stored or transmitted and later reconstructed perfectly. Think of it like packing a complex 3D puzzle into a flat box - you need a systematic way to flatten it and rebuild it exactly as it was!

Your challenge is to design an algorithm to serialize (convert to string) and deserialize (reconstruct from string) an N-ary tree, where each node can have any number of children (not just 2 like binary trees).

Goal: Create two functions:

serialize(root) → converts tree to string
deserialize(data) → reconstructs tree from string

Example: A tree with root 1, children [3,2,4], and node 3 having children [5,6] could be serialized as "1[3[5,6],2,4]" or "1,null,3,2,4,5,6,null,null,null,null" - the format is entirely up to you!

Key requirement: deserialize(serialize(tree)) === tree ✨

Input & Output

example_1.py — Basic N-ary Tree

$ Input: root = [1,null,3,2,4,5,6] Tree structure: 1 /|\ 3 2 4 /| 5 6

› Output: serialize(root) = "1,3,3,2,5,0,6,0,2,0,4,0" deserialize("1,3,3,2,5,0,6,0,2,0,4,0") = original tree

💡 Note: The root node 1 has 3 children. Node 3 has 2 children (5,6). Nodes 2,4,5,6 are leaves with 0 children. The preorder traversal captures the structure perfectly.

example_2.py — Single Node Tree

$ Input: root = [1] Tree structure: 1

› Output: serialize(root) = "1,0" deserialize("1,0") = Node(1) with empty children list

💡 Note: A single node tree serializes to just the value and children count (0). This is the simplest case - one node, no children.

example_3.py — Deep Linear Tree

$ Input: root represents: 1 | 2 | 3 | 4

› Output: serialize(root) = "1,1,2,1,3,1,4,0" deserialize("1,1,2,1,3,1,4,0") = original linear tree

💡 Note: Each non-leaf node has exactly 1 child, creating a linear chain. The serialization shows: 1→1 child→2→1 child→3→1 child→4→0 children.

Visualization

Tap to expand

Understanding the Visualization

Preorder Walk

Walk through the tree like reading a book - top to bottom, left to right, visiting each node exactly once

Record Structure

For each node, record both its value and how many children it has - like DNA base pairs carrying both data and structure info

Perfect Reconstruction

The children count tells us exactly how many subtrees to expect, allowing perfect reconstruction in one pass

Key Takeaway

🎯 Key Insight: By storing both the node value AND children count during preorder traversal, we create a self-describing format that enables perfect single-pass reconstruction without any ambiguity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once during serialization and deserialization

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height, plus O(n) for the result string

✓ Linear Space

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
No restriction on serialization format - be creative!
Must ensure deserialize(serialize(root)) == root

Asked in

G Google 35 a Amazon 28 f Facebook 22 ⊞ Microsoft 18 Apple 12

The optimal solution uses preorder traversal with children count encoding. During serialization, we visit each node and record its value followed by the number of children. During deserialization, we use the children count to know exactly how many subtrees to recursively build. This elegant approach achieves O(n) time and O(h) space complexity while producing compact serializations.

Common Approaches

Approach	Time	Space	Notes
✓ Preorder with Markers (Optimal)	O(n)	O(h)	Use preorder traversal with special markers to encode tree structure elegantly
Brute Force (Level-by-Level with Positions)	O(n²)	O(n²)	Store each node with its complete path information and position markers

Preorder with Markers (Optimal) — Algorithm Steps

For serialize: perform preorder traversal (visit root, then recursively visit all children)
Add node value to result, then add marker for start of children
After processing all children, add end marker to close the children list
For deserialize: use index to track position, recursively build nodes
When encountering end marker, return to indicate no more children

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Root

Add root value and children count to result

Process Children

Recursively process each child in order

Reconstruct

Use children count to know how many subtrees to build

Code -

solution.c — C

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

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

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 addChild(struct Node* parent, struct Node* child) {
    parent->children = (struct Node**)realloc(parent->children, 
        (parent->numChildren + 1) * sizeof(struct Node*));
    parent->children[parent->numChildren] = child;
    parent->numChildren++;
}

void preorderHelper(struct Node* node, char* result, int* pos) {
    if (!node) return;
    
    // Add comma if not first element
    if (*pos > 0) {
        result[(*pos)++] = ',';
    }
    
    // Add node value
    int len = sprintf(result + *pos, "%d", node->val);
    *pos += len;
    
    // Add comma and children count
    len = sprintf(result + *pos, ",%d", node->numChildren);
    *pos += len;
    
    // Recursively add children
    for (int i = 0; i < node->numChildren; i++) {
        result[(*pos)++] = ',';
        preorderHelper(node->children[i], result, pos);
    }
}

char* serialize(struct Node* root) {
    if (!root) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = (char*)malloc(10000);
    int pos = 0;
    preorderHelper(root, result, &pos);
    result[pos] = '\0';
    
    return result;
}

struct Node* buildTreeHelper(char** tokens, int* index, int tokenCount) {
    if (*index >= tokenCount) return NULL;
    
    int val = atoi(tokens[(*index)++]);
    int childrenCount = atoi(tokens[(*index)++]);
    
    struct Node* node = createNode(val);
    
    for (int i = 0; i < childrenCount; i++) {
        struct Node* child = buildTreeHelper(tokens, index, tokenCount);
        if (child) {
            addChild(node, child);
        }
    }
    
    return node;
}

struct Node* deserialize(char* data) {
    if (!data || strlen(data) == 0) return NULL;
    
    // Simple tokenization
    char** tokens = (char**)malloc(1000 * sizeof(char*));
    int tokenCount = 0;
    
    char* dataCopy = strdup(data);
    char* token = strtok(dataCopy, ",");
    
    while (token != NULL && tokenCount < 1000) {
        tokens[tokenCount] = strdup(token);
        tokenCount++;
        token = strtok(NULL, ",");
    }
    
    int index = 0;
    struct Node* result = buildTreeHelper(tokens, &index, tokenCount);
    
    // Cleanup
    for (int i = 0; i < tokenCount; i++) {
        free(tokens[i]);
    }
    free(tokens);
    free(dataCopy);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once during serialization and deserialization

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height, plus O(n) for the result string

✓ Linear Space

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
No restriction on serialization format - be creative!
Must ensure deserialize(serialize(root)) == root

89.3K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Preorder with Markers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler