[LeetCode] 617. Merge Two Binary Trees

You are given two binary trees root1 and root2.

Imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge the two trees into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of the new tree.

Return the merged tree.

Note: The merging process must start from the root nodes of both trees.

Example 1:

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

Example 2:

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

Constraints:

• The number of nodes in both trees is in the range [0, 2000].
• -104 <= Node.val <= 104

合并二叉树。

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/merge-two-binary-trees
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题意是给两个二叉树，请按照 node 的位置对应合并两个二叉树。如果两个二叉树在同一个位置都有各自的 node，就对两个 node 的值相加。

两种解法，BFS 和 DFS。DFS 解法会用到递归，先序遍历的思路做。

时间O(n)

空间O(n)

JavaScript实现

/**
 * @param {TreeNode} t1
 * @param {TreeNode} t2
 * @return {TreeNode}
 */
var mergeTrees = function (t1, t2) {
    // corner case
    if (t1 === null && t2 === null) {
        return null;
    }
    if (t1 === null || t2 === null) {
        return t1 || t2;
    }

    // normal case
    var root = new TreeNode(t1.val + t2.val);
    root.left = mergeTrees(t1.left, t2.left);
    root.right = mergeTrees(t1.right, t2.right);
    return root;
};

 

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        // corner case
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        
        // normal case
        root1.val += root2.val;
        root1.left = mergeTrees(root1.left, root2.left);
        root1.right = mergeTrees(root1.right, root2.right);
        return root1;
    }
}

 

BFS的做法会用到层序遍历，依然还是一个一个 node 扫描。注意需要判断两棵树中是否有空节点，如果有空节点，当前位置的节点值就是另一棵树上那个节点的节点值。

时间O(n)

空间O(n)

JavaScript实现

/**
 * @param {TreeNode} t1
 * @param {TreeNode} t2
 * @return {TreeNode}
 */
var mergeTrees = function (t1, t2) {
    // corner case
    if (t1 === null) return t2;
    if (t2 === null) return t1;

    // normal case
    let stack = [];
    stack.push([t1, t2]);
    while (stack.length) {
        let cur = stack.pop();
        if (cur[0] === null || cur[1] === null) {
            continue;
        }
        cur[0].val += cur[1].val;
        if (cur[0].left === null) {
            cur[0].left = cur[1].left;
        } else {
            stack.push([cur[0].left, cur[1].left]);
        }
        if (cur[0].right === null) {
            cur[0].right = cur[1].right;
        } else {
            stack.push([cur[0].right, cur[1].right]);
        }
    }
    return t1;
};

 

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        // corner case
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }

        // normal case
        Queue<TreeNode[]> queue = new LinkedList<>();
        queue.offer(new TreeNode[] {root1, root2});
        while (!queue.isEmpty()) {
            TreeNode[] cur = queue.poll();
            if (cur[1] == null) {
                continue;
            }
            cur[0].val += cur[1].val;
            if (cur[0].left == null) {
                cur[0].left = cur[1].left;
            } else {
                queue.offer(new TreeNode[] { cur[0].left, cur[1].left });
            }
            if (cur[0].right == null) {
                cur[0].right = cur[1].right;
            } else {
                queue.offer(new TreeNode[] { cur[0].right, cur[1].right });
            }
        }
        return root1;
    }
}

 

LeetCode 题目总结