Validate Binary Tree Nodes

Validate Binary Tree Nodes - Problem

You have n binary tree nodes numbered from 0 to n - 1 where node i has two children leftChild[i] and rightChild[i]. Return true if and only if all the given nodes form exactly one valid binary tree.

If node i has no left child then leftChild[i] will equal -1, similarly for the right child.

Note: The nodes have no values and we only use the node numbers in this problem.

Input & Output

Example 1 — Valid Tree

$ Input: leftChild = [1,-1,0,-1], rightChild = [-1,2,-1,-1]

› Output: false

💡 Note: Node 3 is the only root. Nodes 0,1,2 form a cycle: 0→1→2→0, making node 3 disconnected. This creates multiple components, so it's invalid.

Example 2 — Multiple Roots

$ Input: leftChild = [1,0,3,-1], rightChild = [-1,-1,-1,-1]

› Output: false

💡 Note: Nodes 0 and 1 point to each other as children, creating a cycle. Also node 2 has no parent, creating multiple components.

Example 3 — Simple Valid Tree

$ Input: leftChild = [1,2,-1,-1], rightChild = [-1,-1,-1,-1]

› Output: true

💡 Note: Node 0 is root with left child 1. Node 1 has left child 2. Forms valid tree: 0->1->2

Constraints

n == leftChild.length == rightChild.length
1 ≤ n ≤ 10⁴
-1 ≤ leftChild[i], rightChild[i] ≤ n - 1

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is that a valid binary tree must have exactly one root (node with no parent), no node can have multiple parents, and all nodes must be connected. Best approach uses single pass validation with parent counting and DFS connectivity check. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Validation

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

Validate each tree property independently: count parents, check for cycles, verify connectivity. This approach makes multiple passes through the data.

Single Pass Validation

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

Combines parent counting, root finding, and connectivity checking into a single pass. Uses DFS to validate structure while building parent relationships.

Brute Force Validation — Algorithm Steps

Count parent nodes for each child
Check for cycles using DFS
Verify all nodes are reachable from root

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Parents

Track how many parents each node has

Find Root

Identify the single node with no parent

Check Connectivity

Verify all nodes reachable from root

Code -

solution.c — C

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

void dfs(int node, int* leftChild, int* rightChild, bool* visited, int n) {
    if (node == -1 || node < 0 || node >= n || visited[node]) return;
    visited[node] = true;
    dfs(leftChild[node], leftChild, rightChild, visited, n);
    dfs(rightChild[node], leftChild, rightChild, visited, n);
}

bool solution(int* leftChild, int* rightChild, int n) {
    if (n == 0) return true;
    
    // Count parents for each node
    int* parentCount = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < n; i++) {
        if (leftChild[i] != -1 && leftChild[i] >= 0 && leftChild[i] < n) {
            parentCount[leftChild[i]]++;
            if (parentCount[leftChild[i]] > 1) {
                free(parentCount);
                return false;
            }
        }
        if (rightChild[i] != -1 && rightChild[i] >= 0 && rightChild[i] < n) {
            parentCount[rightChild[i]]++;
            if (parentCount[rightChild[i]] > 1) {
                free(parentCount);
                return false;
            }
        }
    }
    
    // Find root
    int root = -1, rootCount = 0;
    for (int i = 0; i < n; i++) {
        if (parentCount[i] == 0) {
            root = i;
            rootCount++;
        }
    }
    
    if (rootCount != 1) {
        free(parentCount);
        return false;
    }
    
    // Check connectivity
    bool* visited = (bool*)calloc(n, sizeof(bool));
    dfs(root, leftChild, rightChild, visited, n);
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            free(parentCount);
            free(visited);
            return false;
        }
    }
    
    free(parentCount);
    free(visited);
    return true;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse first array
    int leftChild[1000], n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        leftChild[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    // Parse second array
    fgets(line, sizeof(line), stdin);
    int rightChild[1000];
    int idx = 0;
    token = strtok(line, "[],\n ");
    while (token != NULL && idx < n) {
        rightChild[idx++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    bool result = solution(leftChild, rightChild, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Multiple linear passes through nodes

✓ Linear Growth

Space Complexity

O(n)

Arrays to track parents and visited nodes

⚡ Linearithmic Space

35.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler