Serialize and Deserialize BST

Serialize and Deserialize BST - Problem

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

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You need to ensure that a binary search tree can be serialized to a string, and this string can be deserialized to the original tree structure.

The encoded string should be as compact as possible.

Input & Output

Example 1 — Basic BST

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

› Output: "2,1,3"

💡 Note: Preorder traversal of BST [2,1,3] gives "2,1,3". This compact string can reconstruct the original BST using BST properties.

Example 2 — Single Node

$ Input: root = [1]

› Output: "1"

💡 Note: A single node BST serializes to just the node value "1".

Example 3 — Empty Tree

$ Input: root = []

› Output: ""

💡 Note: An empty tree serializes to an empty string and deserializes back to null.

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 binary search tree

Visualization

Tap to expand

Asked in

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

The key insight is leveraging BST properties for compact serialization. The preorder approach stores only node values without structure markers, using BST ordering to reconstruct the tree. Time: O(n), Space: O(h)

Common Approaches

✓ Level Order with Nulls

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

Store the tree level by level, explicitly marking null positions. This is straightforward but not compact as it stores many null values.

Preorder with BST Properties

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

Leverage the BST property where preorder traversal alone is sufficient to reconstruct the tree. No need for null markers since BST ordering determines structure.

Level Order with Nulls — Algorithm Steps

Traverse tree level by level
Include 'null' for missing nodes
Reconstruct by building level by level

Visualization

Tap to expand

Step-by-Step Walkthrough

Level Order Traverse

Visit nodes level by level, marking nulls

Generate String

Create comma-separated string with null markers

Reconstruct

Rebuild tree using queue and level-order pattern

Code -

solution.c — C

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

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

static int* arr[1000];
static int arr_size = 0;
static char result[10000];

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;
}

void preorder(struct TreeNode* node, char* res, int* pos) {
    if (node) {
        if (*pos > 0) {
            res[(*pos)++] = ',';
        }
        int len = sprintf(res + *pos, "%d", node->val);
        *pos += len;
        preorder(node->left, res, pos);
        preorder(node->right, res, pos);
    }
}

char* serialize(struct TreeNode* root) {
    if (!root) {
        strcpy(result, "");
        return result;
    }
    
    int pos = 0;
    result[0] = '\0';
    preorder(root, result, &pos);
    result[pos] = '\0';
    return result;
}

struct TreeNode* buildTree(int** arr, int size, int i) {
    if (i >= size || arr[i] == NULL) return NULL;
    struct TreeNode* node = createNode(*arr[i]);
    node->left = buildTree(arr, size, 2*i + 1);
    node->right = buildTree(arr, size, 2*i + 2);
    return node;
}

char* solution(int** rootArray, int size) {
    if (size == 0) {
        return serialize(NULL);
    }
    
    struct TreeNode* root = buildTree(rootArray, size, 0);
    return serialize(root);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    arr_size = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* p = line + 1; // Skip opening bracket
        char* end = strrchr(line, ']');
        if (end) *end = '\0';
        
        while (*p && arr_size < 1000) {
            // Skip whitespace and commas
            while (*p && (*p == ' ' || *p == ',')) p++;
            if (!*p) break;
            
            if (strncmp(p, "null", 4) == 0) {
                arr[arr_size++] = NULL;
                p += 4;
            } else {
                int* val = (int*)malloc(sizeof(int));
                char* endptr;
                *val = (int)strtol(p, &endptr, 10);
                arr[arr_size++] = val;
                p = endptr;
            }
        }
    }
    
    char* result = solution(arr, arr_size);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once during serialization and deserialization

✓ Linear Growth

Space Complexity

O(n)

Store all nodes plus null markers in the serialized string

⚡ Linearithmic Space

125.0K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Level Order with Nulls — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler