Serialize and Deserialize Binary Tree

Serialize and Deserialize Binary Tree - Problem

Serialization is the process of converting a data structure into a sequence of bits that can be stored in memory, saved to a file, or transmitted over a network. Your task is to design an algorithm that can both serialize a binary tree into a string and deserialize that string back into the original tree structure.

Think of it like creating a blueprint of a tree that you can later use to rebuild the exact same tree. You have complete creative freedom in how you represent the tree as a string - whether using preorder, level-order, or any other format.

The key challenge is ensuring that your serialization captures enough information to perfectly reconstruct the tree, including the structure and null nodes. Your serialize() function should convert a binary tree to a string, and deserialize() should convert that string back to the original tree.

Input & Output

example_1.py — Complete Binary Tree

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

› Output: Serialized: "1,2,null,null,3,4,null,null,5,null,null" (preorder) Deserialized: [1,2,3,null,null,4,5] (original tree structure)

💡 Note: The tree has 5 nodes. Preorder traversal visits: 1 (root) → 2 (left) → null,null (2's children) → 3 (right) → 4,5 (3's children) → null,null,null,null (leaf nulls). The serialization captures the exact structure to enable perfect reconstruction.

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: Serialized: "1,null,null" Deserialized: [1]

💡 Note: A single node tree serializes as the node value followed by two null markers for its missing left and right children. This minimal case demonstrates that even simple structures need null markers for complete reconstruction.

example_3.py — Empty Tree Edge Case

$ Input: root = []

› Output: Serialized: "null" Deserialized: []

💡 Note: An empty tree (null root) serializes to just "null" and deserializes back to null. This edge case is important for handling completely empty inputs and serves as the base case for recursive algorithms.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
Your serialization and deserialization algorithm must be stateless
The serialized string should be as compact as possible while preserving structure

Visualization

Tap to expand

Asked in

a Amazon 87 G Google 72 f Facebook 64 ⊞ Microsoft 58 in LinkedIn 45 U Uber 38

The optimal solution uses preorder traversal with recursive deserialization. During serialization, perform DFS storing node values and 'null' for empty nodes. During deserialization, use a single recursive function that processes one element at a time, building left subtree before right subtree. This achieves O(n) time and O(h) space complexity where h is tree height.

Common Approaches

✓ Level-Order with Queue (BFS)

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

This approach uses a queue to traverse the tree level by level, serializing each node value and explicitly marking null nodes. During deserialization, we rebuild the tree level by level using another queue.

Preorder with Index Tracking

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

This approach uses preorder traversal to serialize the tree, then uses a two-pass method during deserialization: first pass creates all nodes, second pass connects the parent-child relationships using index tracking.

Preorder with Recursive Build (Optimal)

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

This is the most elegant and efficient approach. During serialization, we perform preorder traversal storing values and nulls. During deserialization, we use a single recursive function with an index pointer to rebuild the tree in one pass, following the same preorder pattern.

Level-Order with Queue (BFS) — Algorithm Steps

Serialize: Use a queue to perform level-order traversal
Add each node's value to result, including 'null' for empty nodes
Continue until queue is empty
Deserialize: Split string and use queue to rebuild level by level
For each node, assign left and right children from the serialized data

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node in queue

Process Level 1

Dequeue root, add its children to queue and value to result

Process Level 2

Continue processing each level, marking null nodes

Complete Serialization

Result contains all values in level-order format

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

void preorder(struct TreeNode* node, char* result, int* pos) {
    if (!node) {
        strcpy(result + *pos, "null,");
        *pos += 5;
        return;
    }
    
    char temp[20];
    sprintf(temp, "%d,", node->val);
    strcpy(result + *pos, temp);
    *pos += strlen(temp);
    
    preorder(node->left, result, pos);
    preorder(node->right, result, pos);
}

char* serialize(struct TreeNode* root) {
    char* result = malloc(10000);
    result[0] = '\0';
    int pos = 0;
    
    preorder(root, result, &pos);
    
    if (pos > 0) {
        result[pos - 1] = '\0'; // remove trailing comma
    }
    
    return result;
}

struct TreeNode* build(char** tokens, int* index, int token_count) {
    if (*index >= token_count || strcmp(tokens[*index], "null") == 0) {
        (*index)++;
        return NULL;
    }
    
    struct TreeNode* node = createNode(atoi(tokens[*index]));
    (*index)++;
    node->left = build(tokens, index, token_count);
    node->right = build(tokens, index, token_count);
    return node;
}

struct TreeNode* deserialize(char* data) {
    if (!data || strlen(data) == 0) return NULL;
    
    char* tokens[1000];
    int token_count = 0;
    
    char* data_copy = malloc(strlen(data) + 1);
    strcpy(data_copy, data);
    
    char* token = strtok(data_copy, ",");
    while (token != NULL && token_count < 1000) {
        tokens[token_count] = malloc(strlen(token) + 1);
        strcpy(tokens[token_count], token);
        token_count++;
        token = strtok(NULL, ",");
    }
    
    int index = 0;
    return build(tokens, &index, token_count);
}

struct TreeNode* parseTree(char* s) {
    if (strcmp(s, "[]") == 0) return NULL;
    
    // Remove brackets and parse
    char* content = malloc(strlen(s) + 1);
    strcpy(content, s + 1);
    content[strlen(content) - 1] = '\0';
    
    if (strlen(content) == 0) return NULL;
    
    char* values[1000];
    int value_count = 0;
    
    char* token = strtok(content, ",");
    while (token != NULL && value_count < 1000) {
        // Trim whitespace
        while (*token == ' ') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && *end == ' ') *end-- = '\0';
        
        values[value_count] = malloc(strlen(token) + 1);
        strcpy(values[value_count], token);
        value_count++;
        token = strtok(NULL, ",");
    }
    
    if (value_count == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(values[0]));
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < value_count) {
        struct TreeNode* node = queue[front++];
        
        if (i < value_count && strcmp(values[i], "null") != 0) {
            node->left = createNode(atoi(values[i]));
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < value_count && strcmp(values[i], "null") != 0) {
            node->right = createNode(atoi(values[i]));
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

void parseArray(const char* str, int* arr, int* size) {
    *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;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char inputData[1000];
    fgets(inputData, sizeof(inputData), stdin);
    
    // Remove newline
    inputData[strcspn(inputData, "\n")] = 0;
    
    struct TreeNode* root = parseTree(inputData);
    char* serialized = serialize(root);
    printf("%s\n", serialized);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited once during serialization and deserialization

✓ Linear Growth

Space Complexity

O(n)

Queue storage and string representation both require O(n) space

⚡ Linearithmic Space

73.2K Views

Very High 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

Constraints

Visualization

Related Problems

Common Approaches

Level-Order with Queue (BFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler