Is Array a Preorder of Some ‌Binary Tree

Is Array a Preorder of Some ‌Binary Tree - Problem

Given a 0-indexed integer 2D array nodes, your task is to determine if the given array represents the preorder traversal of some binary tree.

For each index i, nodes[i] = [id, parentId], where:

id is the id of the node at index i
parentId is the id of its parent in the tree (if the node has no parent, then parentId == -1)

Return true if the given array represents the preorder traversal of some tree, and false otherwise.

Note: The preorder traversal of a tree is a recursive way to traverse a tree in which we first visit the current node, then we do the preorder traversal for the left child, and finally, we do it for the right child.

Input & Output

Example 1 — Valid Preorder

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

› Output: true

💡 Note: This represents preorder traversal of tree: 1 is root, 2 is left child of 1, 3 is left child of 2. Preorder visits: 1 → 2 → 3, matching the input order.

Example 2 — Invalid Parent-Child

$ Input: nodes = [[1,-1],[2,1],[3,1],[4,2],[5,3]]

› Output: false

💡 Note: After visiting node 4 (child of 2), we cannot visit node 5 (child of 3) because we would have already finished the left subtree of 1. This violates preorder properties.

Example 3 — Multiple Roots

$ Input: nodes = [[1,-1],[2,-1]]

› Output: false

💡 Note: A binary tree can have only one root node. Having multiple nodes with parentId = -1 makes it invalid.

Constraints

0 ≤ nodes.length ≤ 10⁵
nodes[i].length == 2
1 ≤ id, parentId ≤ 10⁵
parentId == -1 if and only if the node is the root

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that in a valid preorder traversal, we must complete visiting all nodes in the left subtree before visiting any node in the right subtree. Best approach uses a stack simulation to validate the sequence in one pass. Time: O(n), Space: O(n)

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Build Tree Then Validate

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

First build the entire tree structure from parent-child relationships, then do a preorder traversal to generate the expected sequence and compare with input order.

Stack Simulation

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

Maintain a stack of ancestors while processing nodes in order. For each node, ensure it can be properly placed as left or right child based on preorder properties.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nodes[10000][2];
static int stack[10000];

int parseNodes(char* line, int nodes[][2]) {
    int count = 0;
    char* ptr = line;
    
    // Handle empty array
    if (strstr(line, "[]") != NULL) {
        return 0;
    }
    
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[' && *(ptr+1) != ']') {
            // Found start of a node [id, parentId]
            ptr++; // skip '['
            
            // Parse first number (id)
            int id = 0;
            bool negative = false;
            if (*ptr == '-') {
                negative = true;
                ptr++;
            }
            while (*ptr >= '0' && *ptr <= '9') {
                id = id * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) id = -id;
            nodes[count][0] = id;
            
            // Skip comma and spaces
            while (*ptr && *ptr != '-' && (*ptr < '0' || *ptr > '9')) {
                ptr++;
            }
            
            // Parse second number (parentId)
            int parentId = 0;
            negative = false;
            if (*ptr == '-') {
                negative = true;
                ptr++;
            }
            while (*ptr >= '0' && *ptr <= '9') {
                parentId = parentId * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) parentId = -parentId;
            nodes[count][1] = parentId;
            
            count++;
        } else {
            ptr++;
        }
    }
    return count;
}

bool isPreorder(int nodes[][2], int n) {
    if (n == 0) return true;
    
    // Check if first node is root
    if (nodes[0][1] != -1) return false;
    
    // Count roots
    int rootCount = 0;
    for (int i = 0; i < n; i++) {
        if (nodes[i][1] == -1) rootCount++;
    }
    if (rootCount != 1) return false;
    
    // Stack to keep track of available parents
    int stackTop = 0;
    stack[stackTop++] = nodes[0][0]; // Push root
    
    for (int i = 1; i < n; i++) {
        int nodeId = nodes[i][0];
        int parentId = nodes[i][1];
        
        // Find parent in stack
        int parentPos = -1;
        for (int j = 0; j < stackTop; j++) {
            if (stack[j] == parentId) {
                parentPos = j;
                break;
            }
        }
        
        if (parentPos == -1) {
            return false; // Parent not available
        }
        
        // Remove all ancestors after the parent (they are now complete)
        stackTop = parentPos + 1;
        
        // Add current node to stack
        stack[stackTop++] = nodeId;
    }
    
    return true;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int n = parseNodes(line, nodes);
    
    if (isPreorder(nodes, n)) {
        printf("true\n");
    } else {
        printf("false\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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