Is Array a Preorder of Some ‌Binary Tree

Is Array a Preorder of Some ‌Binary Tree - Problem

You're given a 2D array representing nodes of a potential binary tree, where each node is defined as [id, parentId]. Your task is to determine if this array represents a valid preorder traversal of some binary tree.

In a preorder traversal, we visit nodes in this specific order: root → left subtree → right subtree. This means that for any node, all nodes in its left subtree must appear before any nodes in its right subtree in the traversal sequence.

Key Rules:

Each node has a unique id
Root node has parentId = -1
Each node can have at most 2 children (left and right)
The array order must follow preorder traversal rules

Goal: Return true if the given array represents a valid preorder traversal, false otherwise.

Input & Output

example_1.py — Valid Binary Tree

$ Input: [[1,-1],[2,1],[3,1]]

› Output: true

💡 Note: This represents a valid binary tree with root 1 and children 2,3. The preorder traversal would be 1→2→3, which matches the input order.

example_2.py — Invalid Preorder

$ Input: [[1,-1],[3,1],[2,1]]

› Output: false

💡 Note: While this could form a valid binary tree, the order is wrong for preorder traversal. Preorder should be 1→2→3, but we have 1→3→2.

example_3.py — Too Many Children

$ Input: [[1,-1],[2,1],[3,1],[4,1]]

› Output: false

💡 Note: Node 1 has three children (2,3,4), which violates the binary tree constraint of maximum 2 children per node.

Constraints

1 ≤ nodes.length ≤ 10⁵
nodes[i].length == 2
1 ≤ nodes[i][0] ≤ 10⁶
-1 ≤ nodes[i][1] ≤ 10⁶
All node IDs are unique
There is exactly one node with parentId = -1 (root)

Visualization

Tap to expand

Understanding the Visualization

Start with Root

Initialize with the root node (parentId = -1)

Track Path

Use stack to maintain current path from root

Validate Children

Each new node must have its parent in current stack path

Update Stack

Adjust stack based on whether this is first or second child

Key Takeaway

🎯 Key Insight: A valid preorder traversal can be simulated using a stack - we can always determine if the next node belongs by checking if its parent exists in our current traversal path.

Asked in

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

The optimal solution uses a stack-based simulation of preorder traversal. As we process each node, we maintain a stack representing the current path from root and validate that each new node can legally appear next in preorder sequence. This approach validates both tree structure and traversal order in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Stack Simulation (Optimal)	O(n)	O(n)	Use stack to simulate preorder traversal while validating constraints

Stack Simulation (Optimal) — Algorithm Steps

Initialize stack and maps for parent-child relationships
Process each node in the given order
For each node, validate it can be the next node in preorder
Update stack to maintain current traversal path
Check final tree constraints (single root, max 2 children)

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Root

Root node (parent=-1) initializes the stack

First Child

Child nodes are pushed onto stack if parent is at top

Backtrack

Pop stack until we find the correct parent

Second Child

Replace parent with second child (no deeper traversal)

Code -

solution.c — C

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

#define MAX_NODES 1000

bool solution(int nodes[][2], int n) {
    if (n == 0) return false;
    
    int parentMap[MAX_NODES];
    int childrenCount[MAX_NODES] = {0};
    bool nodeExists[MAX_NODES] = {false};
    int stack[MAX_NODES];
    int stackTop = -1;
    
    for (int i = 0; i < n; i++) {
        int nodeId = nodes[i][0];
        int parentId = nodes[i][1];
        
        if (nodeExists[nodeId]) return false;
        nodeExists[nodeId] = true;
        
        parentMap[nodeId] = parentId;
        
        if (parentId != -1) {
            childrenCount[parentId]++;
            if (childrenCount[parentId] > 2) return false;
        }
        
        if (parentId == -1) {
            if (stackTop >= 0) return false;
            stack[++stackTop] = nodeId;
        } else {
            while (stackTop >= 0 && stack[stackTop] != parentId) {
                stackTop--;
            }
            
            if (stackTop < 0 || stack[stackTop] != parentId) {
                return false;
            }
            
            if (childrenCount[parentId] == 1) {
                stack[++stackTop] = nodeId;
            } else {
                stack[stackTop] = nodeId;
            }
        }
    }
    
    int rootCount = 0;
    for (int i = 0; i < n; i++) {
        if (nodes[i][1] == -1) rootCount++;
    }
    return rootCount == 1;
}

int main() {
    int nodes[][2] = {{1, -1}, {2, 1}, {3, 1}};
    int n = 3;
    printf("%s\n", solution(nodes, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through nodes with constant time operations per node

✓ Linear Growth

Space Complexity

O(n)

Stack for traversal simulation plus hash maps for relationships

⚡ Linearithmic Space

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

Stack Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler