Find Root of N-Ary Tree - Practice Coding Problems

Find Root of N-Ary Tree - Problem

Problem: You're given all the nodes of an N-ary tree as an array, but they're in random order! Your task is to find which node is the root.

🌳 What makes this interesting? In a tree, every node except the root has exactly one parent. The root node is special - it's the only node that nobody points to.

Input: An array of Node objects where each node contains:
• val - unique integer value
• children - list of child nodes

Output: Return the root Node object

Key Insight: The root is the only node that never appears in any other node's children list!

Input & Output

example_1.py — Simple Tree

$ Input: tree = [Node(1, [Node(3), Node(2)]), Node(3, [Node(5)]), Node(2), Node(5)]

› Output: Node(1)

💡 Note: Node 1 is the only node that doesn't appear in anyone's children list. Nodes 2, 3, and 5 all appear as children of other nodes.

example_2.py — Single Node

$ Input: tree = [Node(1)]

› Output: Node(1)

💡 Note: With only one node, it must be the root since there are no children anywhere.

example_3.py — Deeper Tree

$ Input: tree = [Node(1, [Node(2), Node(3)]), Node(2, [Node(4)]), Node(3), Node(4)]

› Output: Node(1)

💡 Note: Node 1 is root. Node 2 and 3 are children of 1. Node 4 is child of 2. Only node 1 never appears as anyone's child.

Constraints

The total number of nodes is between [1, 5 * 10⁴]
Each node has a unique value
The input is guaranteed to be a valid tree (exactly one root)
Follow up: Could you solve this with O(1) extra space?

Visualization

Tap to expand

Understanding the Visualization

Identify the pattern

In any tree, every node except root is someone's child

Mark all children

Use a hash set to efficiently track who has parents

Find the orphan

The node without a parent is your root!

Key Takeaway

🎯 Key Insight: In any tree structure, the root is unique because it's the only node that nobody points to!

Asked in

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

The optimal approach uses a hash set to track all child nodes in O(n) time. Since every node except the root has exactly one parent, the root is the only node that never appears in any children list. This elegant solution leverages the fundamental property of trees!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Node)	O(n²)	O(1)	For each node, check if it appears in any other node's children list
Hash Set (Optimal)	O(n)	O(n)	Mark all children in a set, then find the node not in the set

Brute Force (Check Every Node) — Algorithm Steps

For each node in the array
Check all other nodes' children lists
If current node never appears as a child, it's the root
Return the root node

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick candidate

Choose a node to test if it's the root

Scan all children

Check every other node's children list

Found or continue

If candidate never appears as child, it's root!

Code -

solution.c — C

// Definition for a Node.
// struct Node {
//     int val;
//     struct Node** children;
//     int numChildren;
// };

struct Node* findRoot(struct Node** tree, int treeSize) {
    for (int i = 0; i < treeSize; i++) {
        struct Node* candidate = tree[i];
        int isRoot = 1;
        
        // Check if this candidate appears in any node's children
        for (int j = 0; j < treeSize; j++) {
            for (int k = 0; k < tree[j]->numChildren; k++) {
                if (tree[j]->children[k] == candidate) {
                    isRoot = 0;
                    break;
                }
            }
            if (!isRoot) break;
        }
        
        if (isRoot) {
            return candidate;
        }
    }
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we check all other n nodes' children

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

42.0K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler