Clone Binary Tree With Random Pointer

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.

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

Visualization

Tap to expand

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

✓ Optimized

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

Brute Force (Find Random Target Each Time)

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

This approach first creates a complete structural copy of the tree (ignoring random pointers), then makes a second pass to establish random pointers. For each random pointer in the original tree, it searches through both trees to find the corresponding nodes.

One-Pass Hash Table (Optimal)

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

This optimal approach uses a single traversal with smart on-demand node creation. When we encounter a node we haven't seen before, we create it immediately. This handles forward references gracefully and minimizes the number of tree traversals to just one.

Two-Pass Hash Table

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

This approach makes two complete traversals of the tree. The first pass creates all cloned nodes and builds a hash map from original nodes to their clones. The second pass uses this hash map to quickly establish both structural and random pointer connections.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct Node {
    int value;
    int indices[1000];
    int count;
    struct Node* next;
} Node;

int min(int a, int b) {
    return (a < b) ? a : b;
}

int abs_val(int x) {
    return (x < 0) ? -x : x;
}

int hash(int value) {
    return ((value % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
}

Node* findOrCreate(Node** hashTable, int value) {
    int h = hash(value);
    Node* current = hashTable[h];
    
    while (current != NULL) {
        if (current->value == value) {
            return current;
        }
        current = current->next;
    }
    
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = value;
    newNode->count = 0;
    newNode->next = hashTable[h];
    hashTable[h] = newNode;
    return newNode;
}

void freeHashTable(Node** hashTable) {
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* current = hashTable[i];
        while (current != NULL) {
            Node* temp = current;
            current = current->next;
            free(temp);
        }
    }
}

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

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int* solution(int* nums, int numsSize, int* queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    Node* hashTable[HASH_SIZE];
    memset(hashTable, 0, sizeof(hashTable));
    
    // Build hash map: value -> list of indices
    for (int i = 0; i < numsSize; i++) {
        Node* node = findOrCreate(hashTable, nums[i]);
        node->indices[node->count++] = i;
    }
    
    // Sort all index lists
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* current = hashTable[i];
        while (current != NULL) {
            if (current->count > 0) {
                qsort(current->indices, current->count, sizeof(int), compare);
            }
            current = current->next;
        }
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int queryIdx = queries[q];
        int targetVal = nums[queryIdx];
        Node* node = findOrCreate(hashTable, targetVal);
        
        if (node->count <= 1) {  // Only the query index itself
            result[q] = -1;
            continue;
        }
        
        // Binary search for queryIdx position
        int pos = binarySearch(node->indices, node->count, queryIdx);
        
        int minDist = INT_MAX;
        
        // Check left neighbor
        if (pos > 0) {
            int leftIdx = node->indices[pos - 1];
            int linearDist = abs_val(queryIdx - leftIdx);
            int circularDist = numsSize - linearDist;
            int dist = min(linearDist, circularDist);
            minDist = min(minDist, dist);
        }
        
        // Check right neighbor
        if (pos < node->count && node->indices[pos] != queryIdx) {
            int rightIdx = node->indices[pos];
            int linearDist = abs_val(queryIdx - rightIdx);
            int circularDist = numsSize - linearDist;
            int dist = min(linearDist, circularDist);
            minDist = min(minDist, dist);
        } else if (pos + 1 < node->count) {
            int rightIdx = node->indices[pos + 1];
            int linearDist = abs_val(queryIdx - rightIdx);
            int circularDist = numsSize - linearDist;
            int dist = min(linearDist, circularDist);
            minDist = min(minDist, dist);
        }
        
        result[q] = (minDist != INT_MAX) ? minDist : -1;
    }
    
    freeHashTable(hashTable);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    int queries[1000];
    int queriesSize = 0;
    token = strtok(line + 1, ",]");
    while (token != NULL) {
        queries[queriesSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

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