Tree Node - Practice Coding Problems

Tree Node - Problem

Database Medium

Imagine you're building a family tree analyzer! You have a database table containing information about nodes in a tree structure, where each node has an id and a p_id (parent ID).

Your mission: Classify each node as one of three types:

"Root" - The ancestor of all nodes (has no parent, p_id is null)
"Leaf" - A node with no children (appears as p_id for no other nodes)
"Inner" - A node that has both a parent and at least one child

The tree structure is guaranteed to be valid, meaning there are no cycles and exactly one root node.

Table Structure:

Tree
+-------------+------+
| Column Name | Type |
+-------------+------+
| id          | int  |
| p_id        | int  |
+-------------+------+

Return the result showing each node's id and its corresponding type, in any order.

Input & Output

example_1.sql — Basic Tree

$ Input: Tree table: +----+------+ | id | p_id | +----+------+ | 1 | NULL | | 2 | 1 | | 3 | 1 | | 4 | 2 | +----+------+

› Output: +----+-------+ | id | type | +----+-------+ | 1 | Root | | 2 | Inner | | 3 | Leaf | | 4 | Leaf | +----+-------+

💡 Note: Node 1 is the root (p_id is NULL). Node 2 has both parent (1) and child (4), so it's Inner. Nodes 3 and 4 have parents but no children, so they're Leaf nodes.

example_2.sql — Single Node Tree

$ Input: Tree table: +----+------+ | id | p_id | +----+------+ | 1 | NULL | +----+------+

› Output: +----+------+ | id | type | +----+------+ | 1 | Root | +----+------+

💡 Note: A single node tree has only one node, which is the root by definition (p_id is NULL).

example_3.sql — Linear Tree

$ Input: Tree table: +----+------+ | id | p_id | +----+------+ | 1 | NULL | | 2 | 1 | | 3 | 2 | | 4 | 3 | +----+------+

› Output: +----+-------+ | id | type | +----+-------+ | 1 | Root | | 2 | Inner | | 3 | Inner | | 4 | Leaf | +----+-------+

💡 Note: This is a linear tree (like a linked list). Node 1 is Root, nodes 2 and 3 are Inner (have both parent and child), and node 4 is Leaf (has parent but no children).

Visualization

Tap to expand

Understanding the Visualization

Identify Root

Find the node with p_id = NULL - this is the tree root

Map Relationships

Create parent-child mappings to understand tree structure

Count Children

For each node, count how many children it has

Classify Nodes

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

Key Takeaway

🎯 Key Insight: Use SQL JOINs and aggregation to efficiently determine parent-child relationships and classify nodes based on whether they have parents and children.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

JOIN operation with GROUP BY, optimized by database engine

⚡ Linearithmic

Space Complexity

O(n)

Temporary space for JOIN results and grouping

⚡ Linearithmic Space

Constraints

1 ≤ Number of nodes ≤ 10⁴
1 ≤ Node ID ≤ 10⁹
Parent ID (p_id) can be NULL for root node only
The tree structure is guaranteed to be valid (no cycles, single root)
Each node ID appears exactly once in the table

Asked in

a Amazon 45 ⊞ Microsoft 35 G Google 30 f Meta 25

The optimal solution uses SQL LEFT JOIN with GROUP BY to efficiently classify tree nodes. By joining the table with itself on parent-child relationships and counting children, we can determine node types in a single pass: Root (p_id IS NULL), Inner (has children), or Leaf (no children). This approach leverages database optimization for O(n log n) performance.

Common Approaches

Approach	Time	Space	Notes
✓ SQL JOIN with Aggregation (Optimal)	O(n log n)	O(n)	Use LEFT JOIN and COUNT to efficiently determine node types in one pass
Brute Force (Multiple Subqueries)	O(n²)	O(1)	Use nested subqueries to check each node's relationships individually

SQL JOIN with Aggregation (Optimal) — Algorithm Steps

LEFT JOIN the Tree table with itself (parent-child relationship)
GROUP BY the main node id to aggregate child counts
Use CASE statement with COUNT to classify nodes
NULL p_id = Root, COUNT > 0 = Inner, COUNT = 0 = Leaf

Visualization

Tap to expand

Step-by-Step Walkthrough

LEFT JOIN

Join Tree with itself to find parent-child relationships

GROUP BY

Group by node ID to count children for each node

CASE Classification

Use p_id NULL and child count to determine node type

Code -

solution.c — C

// Optimal SQL solution for Tree Node classification
const char* sqlQuery = 
"SELECT \n"
"    t1.id,\n"
"    CASE \n"
"        WHEN t1.p_id IS NULL THEN 'Root'\n"
"        WHEN COUNT(t2.id) > 0 THEN 'Inner'\n"
"        ELSE 'Leaf'\n"
"    END AS type\n"
"FROM Tree t1\n"
"LEFT JOIN Tree t2 ON t1.id = t2.p_id\n"
"GROUP BY t1.id, t1.p_id\n"
"ORDER BY t1.id;";

// Simulating the optimal logic in C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int id;
    int p_id;
    int has_parent;
} Node;

typedef struct {
    int id;
    char type[10];
} Result;

int compare_results(const void *a, const void *b) {
    Result *ra = (Result *)a;
    Result *rb = (Result *)b;
    return ra->id - rb->id;
}

int classifyTreeNodesOptimal(Node* nodes, int count, Result* results) {
    // Build children tracking
    int* hasChildren = (int*)calloc(1000, sizeof(int)); // Assuming max id < 1000
    
    // Mark which nodes have children
    for (int i = 0; i < count; i++) {
        if (nodes[i].has_parent) {
            hasChildren[nodes[i].p_id] = 1;
        }
    }
    
    // Classify each node
    for (int i = 0; i < count; i++) {
        results[i].id = nodes[i].id;
        
        if (!nodes[i].has_parent) {
            strcpy(results[i].type, "Root");
        } else if (hasChildren[nodes[i].id]) {
            strcpy(results[i].type, "Inner");
        } else {
            strcpy(results[i].type, "Leaf");
        }
    }
    
    // Sort results by id
    qsort(results, count, sizeof(Result), compare_results);
    
    free(hasChildren);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

JOIN operation with GROUP BY, optimized by database engine

⚡ Linearithmic

Space Complexity

O(n)

Temporary space for JOIN results and grouping

⚡ Linearithmic Space

Constraints

1 ≤ Number of nodes ≤ 10⁴
1 ≤ Node ID ≤ 10⁹
Parent ID (p_id) can be NULL for root node only
The tree structure is guaranteed to be valid (no cycles, single root)
Each node ID appears exactly once in the table

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

SQL JOIN with Aggregation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler