Merge Two Binary Trees - Practice Coding Problems

Merge Two Binary Trees - Problem

You have two binary trees that need to be combined into one! Imagine placing one tree over another - when nodes from both trees exist at the same position, their values should be added together. When only one tree has a node at a position, that node becomes part of the merged tree unchanged.

Given two binary tree roots root1 and root2, return the root of the new merged binary tree.

Merge Rules:

If both trees have nodes at the same position → sum their values
If only one tree has a node → use that node as-is
If neither tree has a node → no node in result

The merging process starts from the root nodes and works through the entire tree structure.

Input & Output

example_1.py — Basic Tree Merge

$ Input: root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]

› Output: [3,4,5,5,4,null,7]

💡 Note: The merged tree combines overlapping nodes: root (1+2=3), left child (3+1=4), right child (2+3=5). Non-overlapping nodes like 5, 4, and 7 are copied directly.

example_2.py — One Empty Tree

$ Input: root1 = [1], root2 = [1,2]

› Output: [2,2]

💡 Note: Root nodes merge (1+1=2), and since root1 has no left child, root2's left child (2) is copied to the result.

example_3.py — Empty Tree Edge Case

$ Input: root1 = [], root2 = [1,2,3]

› Output: [1,2,3]

💡 Note: When one tree is empty, the result is simply the other tree. No merging is needed.

Constraints

The number of nodes in both trees is in the range [0, 2000]
-10⁴ ≤ Node.val ≤ 10⁴
Trees can be of different heights and structures

Visualization

Tap to expand

Understanding the Visualization

Overlay at Root

Place trees on top of each other, starting from roots

Merge Overlapping

Where both trees have nodes, add their values together

Keep Singles

Where only one tree has a node, keep that node unchanged

Recurse Subtrees

Apply same process to left and right subtrees

Key Takeaway

🎯 Key Insight: Instead of creating an entirely new tree, we can modify one of the input trees in-place, which is more memory-efficient and elegant. The recursive structure naturally handles all edge cases!

Asked in

f Facebook 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

The optimal solution uses recursive DFS to merge trees in-place with O(min(m,n)) time complexity. The key insight is to modify the first tree directly rather than creating a new tree, which saves space and improves performance. Handle base cases where one tree is null, then recursively merge subtrees while updating node values.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Recursive DFS (In-Place Modification)	O(min(m,n))	O(min(m,n))	Modify one of the input trees in-place to avoid creating unnecessary new nodes

Optimized Recursive DFS (In-Place Modification) — Algorithm Steps

If both trees are null, return null
If first tree is null but second exists, return second tree
If second tree is null but first exists, return first tree
If both exist, add second tree's value to first tree's value
Recursively merge left and right subtrees
Return the modified first tree

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at roots

Add root2's value to root1's value

Process left subtree

Recursively merge left children

Process right subtree

Recursively merge right children

Return modified tree

First tree now contains merged result

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* mergeTrees(struct TreeNode* root1, struct TreeNode* root2) {
    if (!root1) return root2;
    if (!root2) return root1;
    
    // Merge in-place
    root1->val += root2->val;
    
    // Recursively merge subtrees
    root1->left = mergeTrees(root1->left, root2->left);
    root1->right = mergeTrees(root1->right, root2->right);
    
    return root1;
}

int main() {
    printf("Optimal tree merging completed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(min(m,n))

We traverse nodes that exist in at least one tree. In the worst case, this is O(m + n).

✓ Linear Growth

Space Complexity

O(min(m,n))

Space used by recursion stack, which goes as deep as the minimum tree height.

⚡ Linearithmic Space

89.3K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Recursive DFS (In-Place Modification) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler