Find Root of N-Ary Tree

Find Root of N-Ary Tree - Problem

You are given all the nodes of an N-ary tree as an array of Node objects, where each node has a unique value.

Return the root of the N-ary tree.

Note: The root is the only node that is not a child of any other node. All other nodes have exactly one parent.

Input & Output

Example 1 — Simple Tree

$ Input: tree = [{"val":1,"children":[3,2,4]},{"val":3,"children":[]},{"val":2,"children":[]},{"val":4,"children":[]}]

› Output: [{"val":1,"children":[3,2,4]},{"val":3,"children":[]},{"val":2,"children":[]},{"val":4,"children":[]}]

💡 Note: Node 1 has children [3,2,4]. Nodes 3, 2, 4 are children of node 1. Only node 1 is never a child of any other node, so it's the root.

Example 2 — Two Levels

$ Input: tree = [{"val":1,"children":[2,3]},{"val":2,"children":[4,5]},{"val":3,"children":[]},{"val":4,"children":[]},{"val":5,"children":[]}]

› Output: [{"val":1,"children":[2,3]},{"val":2,"children":[4,5]},{"val":3,"children":[]},{"val":4,"children":[]},{"val":5,"children":[]}]

💡 Note: Node 1 is the parent of nodes 2 and 3. Node 2 is the parent of nodes 4 and 5. Only node 1 has no parent, making it the root.

Example 3 — Single Node

$ Input: tree = [{"val":1,"children":[]}]

› Output: [{"val":1,"children":[]}]

💡 Note: Only one node exists with no children. This single node is the root by definition.

Constraints

The total number of nodes is between [1, 5 * 10⁴].
Each node has a unique value.
0 <= Node.val <= 10⁵
The input is guaranteed to be a tree (no cycles).
The input will always have exactly one root.

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Facebook 15 M Microsoft 12

The key insight is that the root is the only node that never appears as anyone's child. We can find it using a hash set to track children (O(n) time, O(n) space) or XOR bit manipulation to cancel out parent-child pairs (O(n) time, O(1) space). Best approach is XOR for optimal space complexity.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Sort First

⏱️ Time: N/A Space: N/A

Brute Force Check

⏱️ Time: O(n²) Space: O(1)

For each node, scan all other nodes' children to see if this node appears as a child. The node that never appears as a child is the root.

Two-Pass Hash Set

⏱️ Time: O(n) Space: O(n)

Use a hash set to track all nodes that appear as children. The root is the only node that never appears in this set.

XOR Bit Manipulation

⏱️ Time: O(n) Space: O(1)

XOR all node values twice - once as parents and once as children. Since XOR cancels out duplicates, only the root (which appears as parent but not child) remains.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    qsort(nums1, nums1Size, sizeof(int), compare);
    qsort(nums2, nums2Size, sizeof(int), compare);
    
    int minX = INT_MAX;
    
    // Optimized: Try key removal combinations
    int removalPairs[10][2];
    int pairCount = 0;
    
    if (nums1Size >= 2) {
        removalPairs[pairCount][0] = 0; removalPairs[pairCount][1] = 1; pairCount++;
        removalPairs[pairCount][0] = 0; removalPairs[pairCount][1] = nums1Size-1; pairCount++;
        removalPairs[pairCount][0] = nums1Size-2; removalPairs[pairCount][1] = nums1Size-1; pairCount++;
    }
    if (nums1Size >= 3) {
        removalPairs[pairCount][0] = 0; removalPairs[pairCount][1] = 2; pairCount++;
        removalPairs[pairCount][0] = 1; removalPairs[pairCount][1] = 2; pairCount++;
        removalPairs[pairCount][0] = 1; removalPairs[pairCount][1] = nums1Size-1; pairCount++;
    }
    
    for (int p = 0; p < pairCount; p++) {
        int i = removalPairs[p][0], j = removalPairs[p][1];
        if (i < j && j < nums1Size) {  // Valid indices
            // Create remaining array after removing elements at i and j
            int remaining[1000];
            int remainingSize = 0;
            
            for (int k = 0; k < nums1Size; k++) {
                if (k != i && k != j) {
                    remaining[remainingSize++] = nums1[k];
                }
            }
            
            if (remainingSize == nums2Size) {
                if (nums2Size == 0) {
                    if (0 < minX) {
                        minX = 0;
                    }
                } else {
                    int x = nums2[0] - remaining[0];
                    // Check if all elements match after transformation
                    int valid = 1;
                    for (int k = 0; k < nums2Size; k++) {
                        if (remaining[k] + x != nums2[k]) {
                            valid = 0;
                            break;
                        }
                    }
                    if (valid && x < minX) {
                        minX = x;
                    }
                }
            }
        }
    }
    
    return minX == INT_MAX ? 0 : minX;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int nums1[1000], nums2[1000];
    int nums1Size = 0, nums2Size = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse first array
    char* p = strchr(line, '[');
    if (p) {
        p++;
        if (*p != ']') {  // Not empty array
            char* token = strtok(p, ",]");
            while (token && nums1Size < 1000) {
                nums1[nums1Size++] = atoi(token);
                token = strtok(NULL, ",]");
            }
        }
    }
    
    fgets(line, sizeof(line), stdin);
    
    // Parse second array
    p = strchr(line, '[');
    if (p) {
        p++;
        if (*p != ']') {  // Not empty array
            char* token = strtok(p, ",]");
            while (token && nums2Size < 1000) {
                nums2[nums2Size++] = atoi(token);
                token = strtok(NULL, ",]");
            }
        }
    }
    
    int result = solution(nums1, nums1Size, nums2, nums2Size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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