Find a Corresponding Node of a Binary Tree in a Clone of That Tree

Find a Corresponding Node of a Binary Tree in a Clone of That Tree - Problem

Imagine you have a binary tree and someone creates an exact structural copy of it - same values, same connections, but completely different node objects in memory. Now, you have a reference to a specific node in the original tree, and you need to find the corresponding node (same position, same value) in the cloned tree.

Given:

original: The original binary tree
cloned: An exact structural copy of the original tree
target: A reference to a specific node in the original tree

Goal: Return a reference to the corresponding node in the cloned tree that has the same value and position as the target node.

Note: You cannot modify any trees or nodes, and you must return an actual node reference from the cloned tree, not just the value.

Input & Output

example_1.py — Basic Tree Structure

$ Input: original = [7,4,3,null,null,6,19], cloned = [7,4,3,null,null,6,19], target = 3

› Output: Reference to node with value 3 in cloned tree

💡 Note: The target node has value 3 and is the right child of root in original tree. The corresponding node in cloned tree is also the right child of root with value 3.

example_2.py — Single Node Tree

$ Input: original = [1], cloned = [1], target = 1

› Output: Reference to root node in cloned tree

💡 Note: When the tree has only one node and that node is the target, the corresponding node is simply the root of the cloned tree.

example_3.py — Deep Tree Structure

$ Input: original = [7,4,3,null,null,6,19], cloned = [7,4,3,null,null,6,19], target = 6

› Output: Reference to node with value 6 in cloned tree

💡 Note: The target node with value 6 is located as the left child of node 3. The corresponding node in cloned tree maintains the same structural position.

Visualization

Tap to expand

Understanding the Visualization

Enter Both Rooms

Start at the entrance of both the original room and its mirror copy

Walk in Perfect Sync

Take identical steps in both rooms - left turn in original means left turn in mirror

Recognize Target Location

When you reach the target chair in original room, you're at corresponding chair in mirror room

Mission Complete

Return the chair from the mirror room - it's the exact correspondence you were looking for

Key Takeaway

🎯 Key Insight: By maintaining perfect synchronization between both tree traversals, we guarantee that when we find our target in the original tree, we're automatically positioned at the corresponding node in the cloned tree.

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, target could be the last node visited, requiring traversal of all n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h (O(log n) for balanced trees, O(n) for skewed trees)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
The values of the nodes of the tree are unique
-10⁸ ≤ Node.val ≤ 10⁸
target node is a node from the original tree and is not null

Asked in

f Facebook 15 a Amazon 12 G Google 8 ⊞ Microsoft 6

The optimal approach uses synchronized tree traversal - traversing both trees simultaneously while checking for the target node. When the target is found in the original tree, we return the corresponding node from the cloned tree. This ensures perfect structural correspondence and works correctly even with duplicate values. Time complexity is O(n) with O(h) space for recursion stack.

Common Approaches

Approach	Time	Space	Notes
✓ Synchronized Tree Traversal (Optimal)	O(n)	O(h)	Traverse both trees simultaneously to find corresponding nodes

Synchronized Tree Traversal (Optimal) — Algorithm Steps

Start traversal from roots of both trees simultaneously
At each step, check if current original node equals target
If found, return the current cloned node
Otherwise, recursively traverse left and right subtrees
Maintain perfect synchronization between both trees

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Roots

Begin traversal from both tree roots simultaneously

Synchronized Steps

Move through both trees in perfect lockstep

Target Found

When target found in original, return current cloned node

Code -

solution.c — C

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

// Definition for a binary tree node.
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* traverse(struct TreeNode* origNode, struct TreeNode* cloneNode, struct TreeNode* target) {
    if (!origNode) return NULL;
    
    // Check if we found the target
    if (origNode == target) {
        return cloneNode;
    }
    
    // Recursively search left subtree
    struct TreeNode* leftResult = traverse(origNode->left, cloneNode->left, target);
    if (leftResult) return leftResult;
    
    // Recursively search right subtree
    return traverse(origNode->right, cloneNode->right, target);
}

struct TreeNode* getTargetCopy(struct TreeNode* original, struct TreeNode* cloned, struct TreeNode* target) {
    return traverse(original, cloned, target);
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    // Create example trees
    struct TreeNode* root1 = createNode(7);
    root1->left = createNode(4);
    root1->right = createNode(3);
    
    struct TreeNode* root2 = createNode(7);
    root2->left = createNode(4);
    root2->right = createNode(3);
    
    struct TreeNode* target = root1->right;
    struct TreeNode* result = getTargetCopy(root1, root2, target);
    printf("Found corresponding node with value: %d\n", result->val);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, target could be the last node visited, requiring traversal of all n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h (O(log n) for balanced trees, O(n) for skewed trees)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
The values of the nodes of the tree are unique
-10⁸ ≤ Node.val ≤ 10⁸
target node is a node from the original tree and is not null

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Synchronized Tree Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler