Merge Two Binary Trees

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

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

✓ Optimized Recursive DFS (In-Place Modification)

⏱️ Time: O(min(m,n)) Space: O(min(m,n))

This optimal approach modifies the first tree in-place rather than creating an entirely new tree. We traverse both trees simultaneously and update the first tree's nodes with merged values, only creating new nodes when the first tree lacks a node but the second tree has one.

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>
#include <string.h>
#include <stdbool.h>

#define MAX_NODES 1000
#define NULL_VAL -1001

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;
    
    root1->val += root2->val;
    
    root1->left = mergeTrees(root1->left, root2->left);
    root1->right = mergeTrees(root1->right, root2->right);
    
    return root1;
}

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

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0) return NULL;
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[MAX_NODES];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        if (i < size && arr[i] != NULL_VAL) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        if (i < size && arr[i] != NULL_VAL) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    return root;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            arr[(*size)++] = NULL_VAL;
            p += 4;
        } else {
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        }
    }
}

void treeToArray(struct TreeNode* root, int* result, int* size) {
    *size = 0;
    if (!root) return;
    
    struct TreeNode* queue[MAX_NODES];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            result[(*size)++] = node->val;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            result[(*size)++] = NULL_VAL;
        }
    }
    
    while (*size > 0 && result[*size - 1] == NULL_VAL) {
        (*size)--;
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int tree1Data[MAX_NODES], tree2Data[MAX_NODES];
    int size1, size2;
    
    parseArray(line1, tree1Data, &size1);
    parseArray(line2, tree2Data, &size2);
    
    struct TreeNode* root1 = buildTree(tree1Data, size1);
    struct TreeNode* root2 = buildTree(tree2Data, size2);
    
    struct TreeNode* result = mergeTrees(root1, root2);
    
    int output[MAX_NODES];
    int outputSize;
    treeToArray(result, output, &outputSize);
    
    printf("[");
    for (int i = 0; i < outputSize; i++) {
        if (output[i] == NULL_VAL) {
            printf("null");
        } else {
            printf("%d", output[i]);
        }
        if (i < outputSize - 1) printf(",");
    }
    printf("]\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