Create Binary Tree From Descriptions - Practice Coding Problems

Create Binary Tree From Descriptions - Problem

Create Binary Tree From Descriptions

You're given a collection of parent-child relationships in a binary tree and need to reconstruct the complete tree structure. Each relationship is described as [parent, child, isLeft] where:

If isLeft == 1, the child is the left child of the parent
If isLeft == 0, the child is the right child of the parent

Your task is to build the binary tree from these descriptions and return its root node. Think of it like assembling a family tree from scattered birth certificates - you need to piece together all the relationships to form the complete tree structure.

Goal: Construct and return the root of the binary tree described by the given parent-child relationships.

Input & Output

example_1.py — Basic Tree

$ Input: descriptions = [[20,15,1],[20,17,0],[50,20,1],[50,80,0],[80,19,1]]

› Output: Tree with root node 50

💡 Note: 50 is the root (appears as parent but never as child). 50 has left child 20 and right child 80. 20 has left child 15 and right child 17. 80 has left child 19.

example_2.py — Simple Tree

$ Input: descriptions = [[1,2,1],[2,3,0],[3,4,1]]

› Output: Tree with root node 1

💡 Note: Linear tree structure: 1 is root with left child 2, 2 has right child 3, 3 has left child 4.

example_3.py — Single Relationship

$ Input: descriptions = [[1,2,1]]

› Output: Tree with root node 1

💡 Note: Minimal tree with just root 1 and its left child 2.

Visualization

Tap to expand

Understanding the Visualization

Set Up Organization System

Create a filing system (hash map) to store family members and a notebook (set) to track who are children

Process Each Certificate

For each birth certificate, create person records if they don't exist, then connect the parent-child relationship

Identify the Patriarch/Matriarch

The root of the family tree is the person who appears as a parent but never appears as anyone's child

Key Takeaway

🎯 Key Insight: Use a hash map for O(1) node creation and lookup, track children in a set, then find the root as the node that's a parent but never a child - all in a single pass!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through descriptions array, hash map operations are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n nodes, set stores at most n children

⚡ Linearithmic Space

Constraints

1 ≤ descriptions.length ≤ 10⁴
descriptions[i].length == 3
1 ≤ parent_i, child_i ≤ 10⁵
parent_i != child_i
The binary tree described by descriptions is valid

Asked in

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

The optimal approach uses a hash table to build the tree in a single pass through the descriptions. Create nodes on-demand, establish parent-child relationships immediately, and track children to identify the root (the node that appears as a parent but never as a child). This achieves O(n) time complexity with clean, efficient code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Searches)	O(n²)	O(n)	Create nodes by repeatedly searching through descriptions
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build tree and track relationships in a single pass

Brute Force (Nested Searches) — Algorithm Steps

Extract all unique values and create TreeNode objects
For each description, find parent and child nodes by searching
Connect parent and child based on isLeft flag
Find root by identifying node that appears as parent but not child

Visualization

Tap to expand

Step-by-Step Walkthrough

Create All Nodes

Extract unique values and create TreeNode objects

Search and Connect

For each relationship, search for parent and child nodes

Find Root

Identify the node that has no parent

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createBinaryTree(int** descriptions, int descriptionsSize, int* descriptionsColSize) {
    // Create nodes array
    struct TreeNode* nodes[1001];
    bool exists[1001] = {false};
    
    // Create all unique nodes
    for (int i = 0; i < descriptionsSize; i++) {
        int parent = descriptions[i][0];
        int child = descriptions[i][1];
        
        if (!exists[parent]) {
            nodes[parent] = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            nodes[parent]->val = parent;
            nodes[parent]->left = NULL;
            nodes[parent]->right = NULL;
            exists[parent] = true;
        }
        
        if (!exists[child]) {
            nodes[child] = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            nodes[child]->val = child;
            nodes[child]->left = NULL;
            nodes[child]->right = NULL;
            exists[child] = true;
        }
    }
    
    // Connect relationships
    bool hasParent[1001] = {false};
    for (int i = 0; i < descriptionsSize; i++) {
        int parent = descriptions[i][0];
        int child = descriptions[i][1];
        int isLeft = descriptions[i][2];
        
        hasParent[child] = true;
        
        if (isLeft == 1) {
            nodes[parent]->left = nodes[child];
        } else {
            nodes[parent]->right = nodes[child];
        }
    }
    
    // Find root
    for (int i = 0; i < descriptionsSize; i++) {
        int parent = descriptions[i][0];
        if (!hasParent[parent]) {
            return nodes[parent];
        }
    }
    
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each description, we search through all nodes to find parent and child

⚠ Quadratic Growth

Space Complexity

O(n)

Store n TreeNode objects for the tree

⚡ Linearithmic Space

Constraints

1 ≤ descriptions.length ≤ 10⁴
descriptions[i].length == 3
1 ≤ parent_i, child_i ≤ 10⁵
parent_i != child_i
The binary tree described by descriptions is valid

62.3K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Searches) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler