Binary Tree Nodes - Practice Coding Problems

Binary Tree Nodes - Problem

Database Medium

Given a table representing a binary tree structure, your task is to classify each node based on its position in the tree hierarchy.

The Tree table contains:

N: The node value (unique identifier)
P: The parent node value (NULL for root)

You need to determine the node type for each node:

Root: The top-level node with no parent (P is NULL)
Leaf: A node that has no children
Inner: A node that has both a parent and at least one child

Return the results ordered by node value in ascending order.

Example:

Input:
+---+------+
| N | P    |
+---+------+
| 1 | 2    |
| 2 | 5    |
| 3 | 2    |
| 5 | NULL |
+---+------+

Output:
+---+-------+
| N | Type  |
+---+-------+
| 1 | Leaf  |
| 2 | Inner |
| 3 | Leaf  |
| 5 | Root  |
+---+-------+

Input & Output

example_1.sql — Basic Tree

$ Input: Tree table: +---+------+ | N | P | +---+------+ | 1 | 2 | | 2 | 5 | | 3 | 2 | | 5 | NULL | +---+------+

› Output: +---+-------+ | N | Type | +---+-------+ | 1 | Leaf | | 2 | Inner | | 3 | Leaf | | 5 | Root | +---+-------+

💡 Note: Node 5 is Root (P=NULL), Node 2 is Inner (has children 1,3), Nodes 1,3 are Leaf (no children)

example_2.sql — Single Node

$ Input: Tree table: +---+------+ | N | P | +---+------+ | 1 | NULL | +---+------+

› Output: +---+------+ | N | Type | +---+------+ | 1 | Root | +---+------+

💡 Note: Single node tree where node 1 is the root with no parent and no children

example_3.sql — Linear Tree

$ Input: Tree table: +---+------+ | N | P | +---+------+ | 1 | 2 | | 2 | 3 | | 3 | NULL | +---+------+

› Output: +---+-------+ | N | Type | +---+-------+ | 1 | Leaf | | 2 | Inner | | 3 | Root | +---+-------+

💡 Note: Linear tree: 3 (Root) -> 2 (Inner) -> 1 (Leaf). Node 3 has no parent, node 1 has no children, node 2 has both.

Visualization

Tap to expand

Understanding the Visualization

Identify Root Node

Find the node where P IS NULL - this is the tree root

Find Parent-Child Relationships

JOIN the table with itself to match parents with their children

Count Children

Use COUNT to determine how many children each node has

Classify Node Types

Apply logic: Root (no parent), Leaf (no children), Inner (has both)

Key Takeaway

🎯 Key Insight: Use LEFT JOIN with GROUP BY to efficiently determine parent-child relationships and classify all nodes in a single query pass

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Single pass with JOIN operation, optimized by database engine

⚡ Linearithmic

Space Complexity

O(n)

Temporary space for JOIN operation and grouping

⚡ Linearithmic Space

Constraints

1 ≤ Number of nodes ≤ 10³
1 ≤ N ≤ 100
Each N is unique in the table
Exactly one node will have P = NULL (the root)
All P values (except NULL) must exist as N values in the table

Asked in

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

The optimal solution uses a LEFT JOIN approach to efficiently classify binary tree nodes in a single query. By joining the Tree table with itself on the parent-child relationship and using GROUP BY with COUNT aggregation, we can determine node types: Root (P IS NULL), Inner (has children), and Leaf (no children but has parent).

Common Approaches

Approach	Time	Space	Notes
✓ Multiple Subqueries Approach	O(n²)	O(1)	Use separate subqueries to check parent and child relationships for each node
LEFT JOIN Approach (Optimal)	O(n log n)	O(n)	Use LEFT JOIN to identify parent-child relationships in a single pass

Multiple Subqueries Approach — Algorithm Steps

For each node, check if P IS NULL to identify root
For each node, check if it appears as P in any other row to find if it has children
Classify based on parent and children existence
Order results by node value

Visualization

Tap to expand

Step-by-Step Walkthrough

Check for Root

Scan each node to see if P IS NULL

Check for Children

For each node, scan entire table to see if it appears as a parent

Classify Nodes

Apply CASE logic to determine node type

Code -

solution.c — C

// SQL query for multiple subqueries approach
char* sqlQuery = "\
SELECT \
    N, \
    CASE \
        WHEN P IS NULL THEN 'Root' \
        WHEN N IN (SELECT DISTINCT P FROM Tree WHERE P IS NOT NULL) THEN 'Inner' \
        ELSE 'Leaf' \
    END AS Type \
FROM Tree \
ORDER BY N;\
";

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we scan the table again to check for children

⚠ Quadratic Growth

Space Complexity

O(1)

No additional space needed beyond the result set

✓ Linear Space

Constraints

1 ≤ Number of nodes ≤ 10³
1 ≤ N ≤ 100
Each N is unique in the table
Exactly one node will have P = NULL (the root)
All P values (except NULL) must exist as N values in the table

67.8K Views

High Frequency

~15 min Avg. Time

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

Multiple Subqueries Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler