Serialize and Deserialize BST - Practice Coding Problems

Serialize and Deserialize BST - Problem

String Tree Depth-First Search Breadth-First Search Design Binary Search Tree Binary Tree Medium

Serialize and Deserialize BST

Design an algorithm to serialize (convert to string) and deserialize (reconstruct from string) a Binary Search Tree (BST).

🎯 Goal: Your task is to implement two functions:
• serialize(root) - Convert BST to a compact string representation
• deserialize(data) - Reconstruct the original BST from the string

📦 Key Requirements:
• The encoded string should be as compact as possible
• The deserialized tree must have the exact same structure as the original
• No restrictions on your serialization format

💡 What makes this special: Unlike regular binary trees, BSTs have the property that left children are smaller and right children are larger than their parent. This property can be leveraged to create more efficient serialization!

Example:
Original BST: [2,1,3] → Serialize → "2,1,3" → Deserialize → [2,1,3]

Input & Output

example_1.py — Basic BST

$ Input: root = [2,1,3]

› Output: serialize(root) = "2,1,3", deserialize("2,1,3") = [2,1,3]

💡 Note: The BST with root 2, left child 1, right child 3 is serialized to the compact string "2,1,3" using preorder traversal. During deserialization, we rebuild the exact same structure using BST properties.

example_2.py — Single Node

$ Input: root = [1]

› Output: serialize(root) = "1", deserialize("1") = [1]

💡 Note: A single node BST is serialized as just the node value. The deserialization creates a single node with no children, maintaining the original structure.

example_3.py — Empty Tree

$ Input: root = []

› Output: serialize(root) = "", deserialize("") = []

💡 Note: An empty BST serializes to an empty string. Deserializing an empty string returns null/None, representing an empty tree.

Visualization

Tap to expand

Understanding the Visualization

🌳 Original BST Structure

We start with a BST where left children are smaller and right children are larger than their parent

📝 Serialize with Preorder

Walk the tree in preorder (root→left→right) and collect only the values: no nulls needed!

🔧 Deserialize with Bounds

For each value, use min/max bounds to determine if it goes left or right

✅ Perfect Reconstruction

The BST property ensures we rebuild the exact same structure

Key Takeaway

🎯 Key Insight: The BST ordering property is so powerful that we can reconstruct the entire tree structure from just the node values in preorder sequence, making this the most space-efficient serialization possible!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once for serialization and deserialization

✓ Linear Growth

Space Complexity

O(n)

Store all nodes including nulls, queue for BFS

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
0 ≤ Node.val ≤ 10⁴
The input tree is guaranteed to be a valid binary search tree
Your serialized string should be as compact as possible

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28 Apple 22

The optimal solution leverages the BST property to achieve maximum compactness. By using preorder traversal without null markers, we can serialize a BST using only the actual node values. During deserialization, the BST ordering property (left < root < right) allows us to determine the tree structure using min/max bounds for each subtree. This approach is 75% more compact than naive methods and runs in O(n) time with O(h) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Level Order with Nulls)	O(n)	O(n)	Serialize using level-order traversal with null markers, deserialize by reconstructing level by level
Optimal BST Preorder (No Nulls)	O(n)	O(h)	Leverage BST property to serialize using preorder without null markers
Preorder with Null Markers	O(n)	O(h)	Use preorder traversal with explicit null markers to preserve structure

Brute Force (Level Order with Nulls) — Algorithm Steps

Serialize: Use BFS to traverse tree level by level
Include 'null' markers for missing nodes to preserve structure
Join all values with commas into a string
Deserialize: Split string and rebuild tree level by level
Use queue to track current level nodes and their children

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin with root in queue, output its value

Process Level 1

Add left and right children to queue, output 'null' for missing nodes

Continue Levels

Process each level completely before moving to next

Rebuild Tree

Use queue to reconstruct tree level by level from serialized string

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 = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

char* serialize(struct TreeNode* root) {
    if (!root) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = (char*)malloc(10000);
    result[0] = '\0';
    
    struct TreeNode** queue = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (node) {
            char temp[20];
            sprintf(temp, "%d,", node->val);
            strcat(result, temp);
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            strcat(result, "null,");
        }
    }
    
    // Remove trailing comma
    int len = strlen(result);
    if (len > 0 && result[len-1] == ',') {
        result[len-1] = '\0';
    }
    
    free(queue);
    return result;
}

struct TreeNode* deserialize(char* data) {
    if (!data || strlen(data) == 0) return NULL;
    
    char* token = strtok(data, ",");
    struct TreeNode* root = createNode(atoi(token));
    
    struct TreeNode** queue = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && (token = strtok(NULL, ",")) != NULL) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        // Right child
        if ((token = strtok(NULL, ",")) != NULL && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    free(queue);
    return root;
}

int main() {
    // Example usage
    printf("BST Serialization Example\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once for serialization and deserialization

✓ Linear Growth

Space Complexity

O(n)

Store all nodes including nulls, queue for BFS

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
0 ≤ Node.val ≤ 10⁴
The input tree is guaranteed to be a valid binary search tree
Your serialized string should be as compact as possible

125.0K Views

High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Level Order with Nulls) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler