Validate Binary Tree Nodes - Practice Coding Problems

Validate Binary Tree Nodes - Problem

You're given n binary tree nodes numbered from 0 to n-1. Each node i has at most two children specified by arrays leftChild[i] and rightChild[i].

Your task is to determine whether these nodes form exactly one valid binary tree. A valid binary tree must satisfy:

Single root: Exactly one node has no parent
No cycles: Following parent-child relationships never loops back
Connected: All nodes are reachable from the root
Binary constraint: Each node has at most 2 children and at most 1 parent

If a node has no left or right child, the corresponding array value will be -1.

Example: nodes [0,1,2], leftChild = [1,-1,-1], rightChild = [2,-1,-1] forms tree: 0 → {1, 2}

Input & Output

example_1.py — Valid Binary Tree

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

› Output: true

💡 Note: Forms a valid tree: Node 0 is root with children 1 and 2, Node 2 has child 3. All nodes connected, no cycles, single root.

example_2.py — Multiple Roots

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

› Output: false

💡 Note: Node 3 has two parents (nodes 1 and 2), violating the binary tree constraint that each node has at most one parent.

example_3.py — Disconnected Components

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

› Output: false

💡 Note: Two nodes with no connections form two separate trees (forest), not a single binary tree.

Constraints

1 ≤ n ≤ 10⁴
leftChild.length == rightChild.length == n
-1 ≤ leftChild[i], rightChild[i] ≤ n - 1
A value of -1 means the node has no left/right child

Visualization

Tap to expand

Understanding the Visualization

Count Parents

Count how many parents each person has - valid tree has at most 1 parent per person

Find Ancestor

Identify the family ancestor - exactly one person should have no parents

Trace Lineage

Starting from ancestor, visit all descendants to ensure everyone is connected

Verify Completeness

Confirm that all family members were reached in the lineage trace

Key Takeaway

🎯 Key Insight: A valid binary tree has exactly n-1 edges (parent-child relationships) and forms a connected acyclic graph with a single root. Count in-degrees efficiently to validate structure before checking connectivity.

Asked in

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

The optimal solution uses in-degree counting to find the root node, followed by a single BFS traversal to verify connectivity. Key insights: a valid binary tree has exactly one root (in-degree = 0), no node with multiple parents (in-degree > 1), and all nodes must be reachable from the root. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass with In-Degree Tracking (Optimal)	O(n)	O(n)	Validate tree structure in one pass using in-degree counting and BFS traversal
Brute Force Validation	O(n²)	O(n)	Check all conditions separately with multiple tree traversals

Single Pass with In-Degree Tracking (Optimal) — Algorithm Steps

Count in-degrees while building child relationships
Identify root node (exactly one node with in-degree 0)
Perform BFS/DFS from root counting visited nodes
Verify all nodes visited equals n (connectivity + no cycles)
Early termination on any structural violation

Visualization

Tap to expand

Step-by-Step Walkthrough

Count In-degrees

Track parent count for each node while detecting violations

Find Root

Identify single node with in-degree 0

BFS Traversal

Visit all reachable nodes from root

Validate Count

Ensure all n nodes were visited

Code -

solution.c — C

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

bool validateBinaryTreeNodes(int n, int* leftChild, int leftChildSize, int* rightChild, int rightChildSize) {
    // Count in-degrees to find root
    int* inDegree = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        if (leftChild[i] != -1) {
            inDegree[leftChild[i]]++;
            if (inDegree[leftChild[i]] > 1) {
                free(inDegree);
                return false;  // Early termination
            }
        }
        if (rightChild[i] != -1) {
            inDegree[rightChild[i]]++;
            if (inDegree[rightChild[i]] > 1) {
                free(inDegree);
                return false;  // Early termination
            }
        }
    }
    
    // Find root (exactly one node with in-degree 0)
    int root = -1;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            if (root != -1) {
                free(inDegree);
                return false;  // Multiple roots
            }
            root = i;
        }
    }
    
    free(inDegree);
    if (root == -1) return false;  // No root found
    
    // BFS to check connectivity and count reachable nodes
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = 0;
    queue[rear++] = root;
    int visited = 0;
    
    while (front < rear) {
        int node = queue[front++];
        visited++;
        
        if (leftChild[node] != -1) {
            queue[rear++] = leftChild[node];
        }
        if (rightChild[node] != -1) {
            queue[rear++] = rightChild[node];
        }
    }
    
    free(queue);
    return visited == n;
}

// Example usage
int main() {
    int n = 4;
    int leftChild[] = {1, -1, 3, -1};
    int rightChild[] = {2, -1, -1, -1};
    printf("%s\n", validateBinaryTreeNodes(n, leftChild, 4, rightChild, 4) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count in-degrees O(n) + one traversal from root O(n)

✓ Linear Growth

Space Complexity

O(n)

In-degree array O(n) + BFS queue or DFS recursion stack O(n)

⚡ Linearithmic Space

68.0K Views

High Frequency

~18 min Avg. Time

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

Single Pass with In-Degree Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler