Verify Preorder Serialization of a Binary Tree

Verify Preorder Serialization of a Binary Tree - Problem

One way to serialize a binary tree is to use preorder traversal. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as '#'.

For example, the binary tree can be serialized to the string "9,3,4,#,#,1,#,#,2,#,6,#,#", where '#' represents a null node.

Given a string of comma-separated values preorder, return true if it is a correct preorder traversal serialization of a binary tree.

It is guaranteed that each comma-separated value in the string must be either an integer or a character '#' representing null pointer. You may assume that the input format is always valid.

Note: You are not allowed to reconstruct the tree.

Input & Output

Example 1 — Valid Serialization

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

› Output: true

💡 Note: This represents a valid binary tree where root=9 has children 3 and 2. Node 3 has children 4 and 1. All leaves properly terminated with '#'.

Example 2 — Invalid Serialization

$ Input: preorder = "1,#"

› Output: false

💡 Note: A non-null node must have exactly two children. Node 1 has only one child ('#'), missing the second child.

Example 3 — Single Null Node

$ Input: preorder = "#"

› Output: true

💡 Note: A single null node is a valid empty tree serialization.

Constraints

1 ≤ preorder.length ≤ 10⁴
preorder consist of integers and '#' separated by commas ','.

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 25 f Facebook 22

The key insight is that each node consumes exactly 1 slot but non-null nodes create 2 new slots. By tracking this balance with a simple counter, we can validate the serialization in O(n) time and O(1) space without reconstructing the tree.

Common Approaches

✓ Degree Counting

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

Every node consumes 1 slot and non-null nodes create 2 slots. Track this balance with a counter - start with 1, subtract 1 for each node, add 2 for non-null nodes. Valid if counter stays positive and ends at 0.

Recursive Tree Construction

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

Parse tokens one by one to recursively construct the tree. If we can successfully build a complete tree using all tokens exactly once, the serialization is valid.

Stack-Based Validation

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

Maintain a stack of remaining children count for each node. When we see a node, push 2 to stack. When we see '#', decrement top of stack. Valid if stack becomes empty.

Degree Counting — Algorithm Steps

Initialize slots = 1 (for root)
For each token: slots -= 1
If token is not '#': slots += 2
Valid if slots never goes negative and ends at 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with slots = 1 for root position

Process Each Token

Subtract 1, add 2 if non-null

Validate

Slots should never be negative and end at 0

Code -

solution.c — C

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

bool solution(char* preorder) {
    char tokens[1000][20];
    int tokenCount = 0;
    
    // Parse tokens
    char* token = strtok(preorder, ",");
    while (token != NULL) {
        strcpy(tokens[tokenCount++], token);
        token = strtok(NULL, ",");
    }
    
    int slots = 1; // Start with 1 slot for root
    
    for (int i = 0; i < tokenCount; i++) {
        slots--; // Consume one slot
        
        if (slots < 0) { // More nodes than available slots
            return false;
        }
        
        if (strcmp(tokens[i], "#") != 0) { // Non-null node creates 2 new slots
            slots += 2;
        }
    }
    
    return slots == 0; // All slots should be filled
}

int main() {
    char preorder[10000];
    fgets(preorder, sizeof(preorder), stdin);
    preorder[strcspn(preorder, "\n")] = 0;
    
    bool result = solution(preorder);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n tokens with constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only uses a single integer counter variable

⚡ Linearithmic Space

89.4K Views

Medium 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

Degree Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler