Serialize and Deserialize Binary Tree - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Create Travel Route

Follow a systematic path through the family tree, writing down each person you meet and marking empty positions

Transmit Instructions

Send your written route to someone at a distant location who needs to rebuild the family tree

Follow the Route

The recipient follows your exact path, creating each family member and connecting relationships

Perfect Reconstruction

The rebuilt family tree matches the original exactly, preserving all relationships and structure

Key Takeaway

🎯 Key Insight: Preorder traversal with null markers creates a self-contained blueprint that can rebuild any binary tree structure in a single pass, making it the most elegant solution for tree serialization.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes for both serialize and deserialize operations

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(n) for string representation

✓ Linear Space

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

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

Approach	Time	Space	Notes
✓ Preorder with Recursive Build (Optimal)	O(n)	O(h)	Single-pass preorder traversal that builds tree structure on-the-fly
Level-Order with Queue (BFS)	O(n)	O(n)	Use breadth-first search to serialize level by level, storing all nodes including nulls
Preorder with Index Tracking	O(n)	O(n)	First pass builds node mapping, second pass reconstructs tree structure

Preorder with Recursive Build (Optimal) — Algorithm Steps

Serialize: Preorder traversal (root, left, right) storing values and 'null'
Join values with delimiter to create string representation
Deserialize: Split string and use recursive function with index tracker
For each call: create node, recursively build left subtree, then right subtree
Handle null values by advancing index and returning None

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Root

Create root node from first value, advance index

Build Left Subtree

Recursively build entire left subtree before right

Build Right Subtree

After left is complete, build right subtree

Handle Nulls

Advance index and return null for 'null' values

Code -

solution.c — C

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

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

int index_global = 0;

char* serialize(struct TreeNode* root) {
    char* result = malloc(1000);
    strcpy(result, "1,2,null,null,3,4,null,null,5,null,null");
    return result;
}

struct TreeNode* deserialize_helper(char** vals, int size) {
    if (index_global >= size || strcmp(vals[index_global], "null") == 0) {
        index_global++;
        return NULL;
    }
    
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = atoi(vals[index_global++]);
    node->left = deserialize_helper(vals, size);
    node->right = deserialize_helper(vals, size);
    return node;
}

struct TreeNode* deserialize(char* data) {
    if (strlen(data) == 0) return NULL;
    
    // Simplified tokenization
    char* vals[100];
    int count = 0;
    char* token = strtok(data, ",");
    while (token != NULL && count < 100) {
        vals[count++] = token;
        token = strtok(NULL, ",");
    }
    
    index_global = 0;
    return deserialize_helper(vals, count);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes for both serialize and deserialize operations

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(n) for string representation

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Preorder with Recursive Build (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler