Verify Preorder Serialization of a Binary Tree

Verify Preorder Serialization of a Binary Tree - Problem

Imagine you have a binary tree that's been flattened into a string using preorder traversal - where we visit the root first, then the left subtree, then the right subtree. When we encounter a node with a value, we record it. When we hit a null pointer, we mark it with #.

For example, the tree:

becomes the serialized string: "9,3,4,#,#,1,#,#,2,#,6,#,#"

Your mission: Given a comma-separated string, determine if it represents a valid preorder serialization of some binary tree. You cannot reconstruct the actual tree - you must verify the structure using only the string!

The tricky part? Every valid binary tree serialization must have exactly the right number of null markers (#) in exactly the right positions. Too few nulls means incomplete leaf nodes, too many means extra dangling pointers.

Input & Output

example_1.py — Valid Tree Serialization

$ Input: preorder = "9,3,4,#,#,1,#,#,2,#,6,#,#"

› Output: true

💡 Note: This represents a valid binary tree. The preorder traversal visits: root(9), left subtree(3,4,#,#,1,#,#), right subtree(2,#,6,#,#). Each non-null node has exactly 2 children (which may be null), and the structure is properly balanced.

example_2.py — Invalid - Missing Null

$ Input: preorder = "1,#"

› Output: false

💡 Note: This is invalid because node 1 has only one child specified (#). In a proper binary tree serialization, every non-null node must have exactly 2 children (left and right), even if they are null. The correct serialization would be "1,#,#".

example_3.py — Invalid - Extra Nodes

$ Input: preorder = "9,#,#,1"

› Output: false

💡 Note: After processing "9,#,#" we have a complete tree (root with two null children). The extra "1" at the end makes this invalid - there's nowhere in the tree structure for this additional node to belong.

Constraints

1 ≤ preorder.length ≤ 10⁴
preorder consists of integers and '#' separated by commas
No consecutive commas (input format is always valid)
Each integer is in range [-1000, 1000]

Visualization

Tap to expand

Understanding the Visualization

Parse the Recipe

Split the serialization string into individual components (nodes and null markers)

Stack Construction

Use a stack to simulate building the tree structure, adding each component as we encounter it

Identify Complete Subtrees

When we see a pattern of [parent, #, #], we know this subtree is complete and can be collapsed

Collapse and Validate

Replace completed subtrees with a single # and continue until we either finish with one # (valid) or get stuck (invalid)

Key Takeaway

🎯 Key Insight: Every non-null node contributes +1 to the 'degree balance' (creates 2 children, consumes 1 parent slot), while null nodes contribute -1. A valid tree maintains non-negative balance throughout and ends at exactly 0.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a stack-based simulation to validate the preorder serialization. As we process each node, we push it onto a stack and check if we can collapse completed subtrees (when we see a parent followed by two null children). A valid serialization will end with exactly one '#' remaining in the stack, representing the final collapsed tree. This solution runs in O(n) time with O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-based One Pass (Optimal)	O(n)	O(n)	Use a stack to track nodes and simulate tree construction in one pass
Brute Force (Recursive Simulation)	O(n²)	O(n)	Recursively simulate tree construction and validate at each step

Stack-based One Pass (Optimal) — Algorithm Steps

Split the preorder string into individual tokens
Push each token onto a stack
After each push, check if the top two elements are '#' (null nodes)
If so, and there's a non-null parent, replace parent + two nulls with a single '#'
Continue until no more collapses are possible
Valid serialization ends with stack containing only one '#'

Visualization

Tap to expand

Step-by-Step Walkthrough

Push nodes

Add each preorder node to the stack

Detect completion

When top 2 elements are '#' and 3rd is not '#', we have a completed subtree

Collapse subtree

Replace parent + 2 nulls with single '#'

Final validation

Valid tree ends with exactly one '#' in stack

Code -

solution.c — C

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

bool isValidSerialization(char* preorder) {
    char stack[1000][10];
    int stackSize = 0;
    
    char* token = strtok(preorder, ",");
    while (token != NULL) {
        strcpy(stack[stackSize++], token);
        
        // Collapse completed subtrees
        while (stackSize >= 3 && 
               strcmp(stack[stackSize-1], "#") == 0 && 
               strcmp(stack[stackSize-2], "#") == 0 && 
               strcmp(stack[stackSize-3], "#") != 0) {
            stackSize -= 3;
            strcpy(stack[stackSize++], "#");
        }
        
        token = strtok(NULL, ",");
    }
    
    return stackSize == 1 && strcmp(stack[0], "#") == 0;
}

int main() {
    char preorder[10000];
    fgets(preorder, sizeof(preorder), stdin);
    
    preorder[strcspn(preorder, "\n")] = 0;
    if (preorder[0] == '"') {
        memmove(preorder, preorder + 1, strlen(preorder));
        preorder[strlen(preorder) - 1] = 0;
    }
    
    printf("%s\n", isValidSerialization(preorder) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes, with each node pushed and popped at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can grow up to the height of the tree in worst case

⚡ Linearithmic Space

32.0K Views

Medium-High Frequency

~18 min Avg. Time

1.4K 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

Stack-based One Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler