Clone Binary Tree With Random Pointer - Practice Coding Problems

Clone Binary Tree With Random Pointer - Problem

Imagine you need to create a perfect duplicate of a special binary tree where each node has an unexpected twist - besides the usual left and right child pointers, every node also has a random pointer that can point to any node in the tree (or be null).

Your mission is to create a deep copy of this tree, ensuring that:

Every node value is copied exactly
The structure (left/right relationships) is preserved
All random pointers point to the correct corresponding nodes in the new tree

The challenge lies in maintaining the random pointer relationships - when you copy node A that points randomly to node B, the copied node A must point to the copied node B, not the original!

Input: Root of the original binary tree with random pointers
Output: Root of the completely independent cloned tree

Input & Output

example_1.py — Basic Tree with Random Pointer

$ Input: root = [1, null], where node 1 has random pointer to itself

› Output: Cloned tree with same structure and random pointer relationships

💡 Note: Single node tree where the random pointer points to the node itself. The cloned node should also point to itself via the random pointer.

example_2.py — Tree with Cross Random Pointers

$ Input: root = [1, 2, 3, null, null, null, null], node 2's random points to node 3

› Output: Cloned tree where cloned node 2's random points to cloned node 3

💡 Note: Tree with left and right children where a leaf node's random pointer crosses to the other side of the tree. The clone must maintain this cross-reference correctly.

example_3.py — Empty Tree Edge Case

$ Input: root = null

› Output: null

💡 Note: Empty tree should return null. This tests the base case handling of the recursive solution.

Visualization

Tap to expand

Understanding the Visualization

Encounter Node

When we visit a node, check if we've already created its clone

Create Clone

If it's new, create the clone and immediately store the mapping

Handle Pointers

Recursively process left, right, and random pointers

Return Clone

Return the clone, which now has all connections properly established

Key Takeaway

🎯 Key Insight: Use memoization to create clones on-demand, handling forward references and cycles naturally in a single traversal

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the tree, each node visited exactly once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n nodes plus O(h) recursion stack space

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
Each node's value is unique, and -10⁶ ≤ Node.val ≤ 10⁶
The random pointer can point to any node in the tree or be null
The tree may contain cycles through random pointers
All Node.val are unique

Asked in

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

The optimal solution uses a one-pass recursive approach with memoization. By maintaining a hash map of original-to-clone node mappings, we can handle forward references and cycles gracefully. The key insight is to create cloned nodes on-demand during DFS traversal, storing each mapping immediately to avoid duplicate creation. This achieves O(n) time and O(n) space complexity with elegant handling of all edge cases.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Find Random Target Each Time)	O(n²)	O(h)	Clone the tree structure first, then for each random pointer, search to find the target
One-Pass Hash Table (Optimal)	O(n)	O(n)	Create nodes and connections on-demand during a single traversal
Two-Pass Hash Table	O(n)	O(n)	First pass creates all nodes and mapping, second pass sets up all pointers

Brute Force (Find Random Target Each Time) — Algorithm Steps

Traverse original tree and create structural clone (left/right only)
For each node in original tree with a random pointer
Find the target node's position in the original tree
Find the corresponding cloned node and cloned target
Set up the random pointer connection

Visualization

Tap to expand

Step-by-Step Walkthrough

Clone Structure

Create complete structural copy ignoring random pointers

Find Random Target

For each random pointer, trace path from root to target

Recreate Path

Follow the same path in cloned tree to establish connection

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* left;
    struct Node* right;
    struct Node* random;
} Node;

typedef struct NodeCopy {
    int val;
    struct NodeCopy* left;
    struct NodeCopy* right;
    struct NodeCopy* random;
} NodeCopy;

NodeCopy* cloneStructure(Node* node) {
    if (!node) return NULL;
    
    NodeCopy* clone = (NodeCopy*)malloc(sizeof(NodeCopy));
    clone->val = node->val;
    clone->left = cloneStructure(node->left);
    clone->right = cloneStructure(node->right);
    clone->random = NULL;
    
    return clone;
}

bool getPath(Node* root, Node* target, char* path, int* pathLen) {
    if (!root) return false;
    if (root == target) return true;
    
    path[*pathLen] = 'L';
    (*pathLen)++;
    if (getPath(root->left, target, path, pathLen)) return true;
    (*pathLen)--;
    
    path[*pathLen] = 'R';
    (*pathLen)++;
    if (getPath(root->right, target, path, pathLen)) return true;
    (*pathLen)--;
    
    return false;
}

NodeCopy* followPath(NodeCopy* root, char* path, int pathLen) {
    NodeCopy* current = root;
    for (int i = 0; i < pathLen; i++) {
        current = (path[i] == 'L') ? current->left : current->right;
    }
    return current;
}

void setupRandom(Node* original, NodeCopy* cloned, Node* originalRoot, NodeCopy* clonedRoot) {
    if (!original) return;
    
    if (original->random) {
        char path[1000];
        int pathLen = 0;
        getPath(originalRoot, original->random, path, &pathLen);
        cloned->random = followPath(clonedRoot, path, pathLen);
    }
    
    setupRandom(original->left, cloned->left, originalRoot, clonedRoot);
    setupRandom(original->right, cloned->right, originalRoot, clonedRoot);
}

NodeCopy* copyRandomBinaryTree(Node* root) {
    if (!root) return NULL;
    
    NodeCopy* clonedRoot = cloneStructure(root);
    setupRandom(root, clonedRoot, root, clonedRoot);
    
    return clonedRoot;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially search through n nodes to find the random target and its clone

⚠ Quadratic Growth

Space Complexity

O(h)

Only recursion stack space proportional to tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
Each node's value is unique, and -10⁶ ≤ Node.val ≤ 10⁶
The random pointer can point to any node in the tree or be null
The tree may contain cycles through random pointers
All Node.val are unique

58.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Find Random Target Each Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler