Clone N-ary Tree - Practice Coding Problems

Clone N-ary Tree - Problem

Imagine you need to create an exact duplicate of a complex organizational chart or family tree structure. That's exactly what we're doing here - creating a deep copy of an N-ary tree!

Given the root of an N-ary tree, your task is to return a complete clone of the entire tree structure. Each node in the tree contains:

An integer value (val)
A list of child nodes (children)

The clone must be completely independent - modifying the original tree should not affect the cloned tree and vice versa. Think of it as creating a photocopy of a document where changes to the original don't affect the copy.

Key Challenge: Unlike binary trees which have at most 2 children, N-ary trees can have any number of children, making the cloning process more complex as we need to handle variable-length child lists.

Input & Output

example_1.py — Basic N-ary Tree

$ Input: root = [1,null,3,2,4,null,5,6]

› Output: Cloned tree with same structure: [1,null,3,2,4,null,5,6]

💡 Note: The tree has root with value 1 and three children (3,2,4). Node 3 has two children (5,6). The clone maintains the exact same structure but creates completely new node objects.

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: Cloned single node: [1]

💡 Note: A tree with only one node (the root) is cloned to create a new node with the same value but different memory address.

example_3.py — Empty Tree

$ Input: root = null

› Output: null

💡 Note: An empty tree (null root) returns null as there's nothing to clone. This is the base case for our recursive solution.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin the cloning process at the root of the original tree

Create Clone

Create a new node with the same value as the current node

Process Children

Recursively clone each child node in the children list

Link Structure

Connect cloned children to their cloned parent

Complete Tree

Return the root of the completely independent cloned tree

Key Takeaway

🎯 Key Insight: Tree cloning requires creating completely independent node objects while preserving the exact same structural relationships - like making a perfect organizational chart copy where changes to one don't affect the other.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once, hash map operations are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n entries plus recursion stack depth

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
The depth of the n-ary tree is less than or equal to 1000
Follow up: Can you solve this problem iteratively using BFS?

Asked in

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

The optimal approach uses recursive DFS traversal with optional hash map memoization. For each node, create a new node with the same value, then recursively clone all children. The hash map prevents duplicate work and handles edge cases. Time complexity is O(n) where n is the number of nodes, and space complexity is O(h + n) for recursion depth and clone storage.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS (Naive Approach)	O(n)	O(h)	Simple recursive approach without optimization
DFS with Memoization (Hash Map)	O(n)	O(n)	Use hash map to track cloned nodes and avoid duplicate work

Recursive DFS (Naive Approach) — Algorithm Steps

Base case: if root is null, return null
Create a new node with the same value as root
Recursively clone each child and add to new node's children list
Return the cloned node

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin cloning process at the root node

Create Clone Node

Create a new node with the same value

Process Children

Recursively clone each child node

Link Children

Add cloned children to the new node's children list

Code -

solution.c — C

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

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

struct Node* createNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->numChildren = 0;
    node->children = NULL;
    return node;
}

struct Node* cloneTree(struct Node* root) {
    if (!root) return NULL;
    
    // Create new node with same value
    struct Node* clonedNode = createNode(root->val);
    clonedNode->numChildren = root->numChildren;
    
    if (root->numChildren > 0) {
        clonedNode->children = (struct Node**)malloc(root->numChildren * sizeof(struct Node*));
        
        // Recursively clone all children
        for (int i = 0; i < root->numChildren; i++) {
            clonedNode->children[i] = cloneTree(root->children[i]);
        }
    }
    
    return clonedNode;
}

int main() {
    // Test the solution
    struct Node* root = createNode(1);
    root->numChildren = 3;
    root->children = (struct Node**)malloc(3 * sizeof(struct Node*));
    root->children[0] = createNode(3);
    root->children[1] = createNode(2);
    root->children[2] = createNode(4);
    
    struct Node* cloned = cloneTree(root);
    printf("Original root: %d, Cloned root: %d\n", root->val, cloned->val);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once where n is the total number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion depth equals tree height h, plus space for the cloned tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
The depth of the n-ary tree is less than or equal to 1000
Follow up: Can you solve this problem iteratively using BFS?

58.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

Recursive DFS (Naive Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler