LeetCode 617. 合并二叉树(C#实现)——二叉树,递归,迭代

一、问题

https://leetcode-cn.com/problems/merge-two-binary-trees/

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入: 
    Tree 1                     Tree 2                  
          1                         2                             
         /                        /                             
        3   2                     1   3                        
       /                                                    
      5                             4   7                  
输出: 
合并后的树:
         3
        / 
       4   5
      /     
     5   4   7

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

二、GitHub实现：https://github.com/JonathanZxxxx/LeetCode/blob/master/MergeClass.cs

　　Blog：https://www.cnblogs.com/zxxxx/

三、思路

　　1、递归：对两棵树进行前序遍历，并将对应的节点合并。将当前节点的值进行相加，并对左右孩子进行递归合并，如果为空，就返回另外一棵树作为结果。

　　2、迭代：将两棵树的根节点入栈，栈中的每个元素都存放两个根节点，栈顶为当前需要处理的根节点。在每次迭代中，去除栈顶元素并移出栈，并将他们的值相加；如果两个节点都有左孩子，入栈，如果只有一个节点左孩子有值，将其作为第一个节点的左孩子，如果两个节点的左孩子都为空，不做任何处理；右孩子同理。迭代完成后返回第一棵树作为结果。

四、代码

    public class MergeClass
    {
        /// <summary>
        /// 递归
        /// </summary>
        /// <param name="t1"></param>
        /// <param name="t2"></param>
        /// <returns></returns>
        public TreeNode MergeTrees(TreeNode t1, TreeNode t2)
        {
            if (t1 == null)
            {
                return t2;
            }
            if (t2 == null)
            {
                return t1;
            }
            t1.val += t2.val;
            t1.left = MergeTrees(t1.left, t2.left);
            t1.right = MergeTrees(t1.right, t2.right);
            return t1;
        }

        /// <summary>
        /// 栈迭代
        /// </summary>
        /// <param name="t1"></param>
        /// <param name="t2"></param>
        /// <returns></returns>
        public TreeNode MergeTrees2(TreeNode t1, TreeNode t2)
        {
            if (t1 == null)
            {
                return t2;
            }
            var stack = new Stack<TreeNode[]>();
            stack.Push(new TreeNode[] { t1, t2 });
            while (stack.Any())
            {
                var pop = stack.Pop();
                if (pop[0] == null || pop[1] == null)
                {
                    continue;
                }
                pop[0].val += pop[1].val;
                if (pop[0].left == null)
                {
                    pop[0].left = pop[1].left;
                }
                else
                {
                    stack.Push(new TreeNode[] { pop[0].left, pop[1].left });
                }
                if (pop[0].right == null)
                {
                    pop[0].right = pop[1].right;
                }
                else
                {
                    stack.Push(new TreeNode[] { pop[0].right, pop[1].right });
                }
            }
            return t1;
        }

        /// <summary>
        /// 队列迭代
        /// </summary>
        /// <param name="t1"></param>
        /// <param name="t2"></param>
        /// <returns></returns>
        public TreeNode MergeTrees3(TreeNode t1, TreeNode t2)
        {
            if (t1 == null)
            {
                return t2;
            }
            var queue = new Queue<TreeNode[]>();
            queue.Enqueue(new TreeNode[] { t1, t2 });
            while (queue.Any())
            {
                var current = queue.Dequeue();
                if (current[0] == null || current[1] == null)
                {
                    continue;
                }
                current[0].val += current[1].val;
                if (current[0].left == null)
                {
                    current[0].left = current[1].left;
                }
                else
                {
                    queue.Enqueue(new TreeNode[] { current[0].left, current[1].left });
                }
                if (current[0].right == null)
                {
                    current[0].right = current[1].right;
                }
                else
                {
                    queue.Enqueue(new TreeNode[] { current[0].right, current[1].right });
                }
            }
            return t1;
        }

        public class TreeNode
        {
            public int val;
            public TreeNode left;
            public TreeNode right;
            public TreeNode(int x) { val = x; }
        }

    }