leetcode617.合并二叉树

题目：leetcode617.合并二叉树

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

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

返回合并后的二叉树。

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

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

解题思路：参考官方题解 

目录

解法一：深度优先（递归法）

解法二：广度优先（迭代法）         

小结：

---

解法一：深度优先（递归法）

        深度优先的思想，通过递归构建左右子树，只不过构建的子树根节点的val为原树节点值之和。在构建节点值时，会有以下情况：

        ① root1和root2都不为空，这时新节点值为两者之和

        ② root1和root2两者有一个为空，那么新节点值为不为空的节点值

        ③ 两者都为空的情况下，结束递归，返回null

代码实现：在代码实现时，我们为了避免了额外的空间浪费，没有创建新节点，而是通过重新构造root1节点，将root1作为新的节点返回

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null){
            return root2;
        }
        if(root2 == null){
            return root1;
        }
        //调用merge
        return merge(root1,root2);
    }

    public TreeNode merge(TreeNode node1,TreeNode node2){
        //有一个为null直接返回
        if(node1 == null || node2 == null){
            return node1== null ? node2 : node1;
        }
        //重新构建node1
        node1.val += node2.val;
        //递归创建左子树
        node1.left = merge(node1.left,node2.left);
        //递归创建右子树
        node1.right = merge(node1.right,node2.right);
        //将重新构造的node1返回，作为新节点
        return node1;
    }
}

解法二：广度优先（迭代法）         

        广度优先遍历实现的话，我们就需要借助栈这一数据结构，通过栈的特点（先进先出，后进后出）来帮助我们实现顺序遍历。

        和解法一大致思路一样，两种解法的区别在于构建节点的顺序有别，具体参考深度优先遍历和广度优先遍历的区别。

代码实现：

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null || root2 == null){
            return root1 == null ? root2 : root1;
        }
        //创建两个队列用来存储两棵树
        Queue<TreeNode> queue1 = new LinkedList<TreeNode>();
        Queue<TreeNode> queue2 = new LinkedList<TreeNode>();
        //将root1，root2加入队列
        queue1.offer(root1);
        queue2.offer(root2);

        root1.val += root2.val;
        while(!queue1.isEmpty() && !queue2.isEmpty()){
            TreeNode node1 = queue1.poll();
            TreeNode node2 = queue2.poll();
            //创建左节点
            if(node1.left != null && node2.left != null){
                //两个左节点都不为空
                node1.left.val += node2.left.val;
                //将两个左节点入栈,后面继续遍历
                queue1.offer(node1.left);
                queue2.offer(node2.left);
            }else if(node1.left == null){
                //若node1.left为空,将node2.left赋值给node1.left
                node1.left = node2.left;
                //不入栈，后序也不再遍历该节点
            }
            //创建右节点
            if(node1.right!= null && node2.right != null){
                //两个左节点都不为空
                node1.right.val += node2.right.val;
                //将两个左节点入栈,后面继续遍历
                queue1.offer(node1.right);
                queue2.offer(node2.right);
            }else if(node1.right == null){
                //若node1.right为空,将node2.right赋值给node1.rithg
                node1.right = node2.right;
                //不入栈，后序也不再遍历该节点
            }
        }
        return root1;
    }
}

小结：

        两种方法共同的思想是：当node1和node2有一个为空时就停止遍历，只不过两种方法用各自的方式去实现“停止”。