[617]Merge Two Binary Trees

Given two binary trees and 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 them 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 new tree.

Example 1:

Input: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
Output: 
Merged tree:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

 

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

思路：层次遍历，往队列里每次塞进去两棵树相同位置上不为空的节点，因为最终输出的是左树，则节点一共有以下3种情况：

1.左右树对应位置上孩子只有左树为空，则把右树孩子赋给左树对应位置

2.左右树对应位置上孩子都不为空，直接塞进队列里就可以了，出队列时累加起来给左树

3.左右树对应位置上孩子只有右树为空，则不需要处理，我们需要输出的是左边的树(X)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution 
{
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) 
    {
        if(t1 == nullptr) return t2;
        if(t2 == nullptr) return t1;
        if(t1 == nullptr && t2 == nullptr) return nullptr;
        else
        {
          queue<TreeNode*>q;
          q.push(t1);
          q.push(t2);
          while(!q.empty())
          {
            TreeNode* l1 = q.front();
            q.pop();
            TreeNode* l2 = q.front();
            q.pop();
            l1->val +=l2->val;
            if(l1->left != nullptr && l2->left!=nullptr)
            {
              q.push(l1->left);
              q.push(l2->left);
            }
            if(l1->right != nullptr && l2->right!=nullptr)
            {
              q.push(l1->right);
              q.push(l2->right);
            }
            if(l1->left == nullptr && l2->left != nullptr )
            {
              l1->left = l2->left;
            }
            if(l1->right == nullptr && l2->right != nullptr)
            {
              l1->right = l2->right;
            }
          }
          return t1;
        }
    }
};