每日一题-16-合并二叉树

 

# 每日一题-16-合并二叉树

合并二叉树

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

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

示例 1:

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

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

1.使用递归来实现对整个树进行遍历，同时创建一个新的树来接受连个旧的树合并以后产生的新的树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == nullptr || root2 == nullptr){
            if(root1 == nullptr){
                return root2;
            }else{
                return root1;
            }
        }
        TreeNode* merge = new TreeNode(root1->val + root2->val);
        merge->left = mergeTrees(root1->left,root2->left);
        merge->right = mergeTrees(root1->right,root2->right);

        return merge;     
    }

};

2.使用广度优先遍历的方法进行遍历两个树，然后将两棵树合并

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == nullptr){
            return root2;
        }
        if(root2 == nullptr){
            return root1;
        }

        TreeNode* merge = new TreeNode(root1->val + root2->val);
        queue<TreeNode*> q;
        queue<TreeNode*> que1;
        queue<TreeNode*> que2;

        q.push(merge);
        que1.push(root1);
        que2.push(root2);

        while(!que1.empty() && !que2.empty()){
            TreeNode* node = q.front();
            TreeNode* node1 = que1.front();
            TreeNode* node2 = que2.front();

            q.pop();
            que1.pop();
            que2.pop();

            TreeNode* left1 = node1->left;
            TreeNode* right1 = node1->right;
            TreeNode* left2 = node2->left;
            TreeNode* right2 = node2->right;
            if(left1 != nullptr || left2 != nullptr){
                if(left1 != nullptr && left2 != nullptr){
                    TreeNode* left = new TreeNode(left1->val+left2->val);
                    node->left = left;
                    q.push(left);
                    que1.push(left1);
                    que2.push(left2);
                }else if(left1 != nullptr){
                    node->left = left1;
                }else if(left2 != nullptr){
                    node->left = left2;
                }
            }

            if(right1 != nullptr || right2 != nullptr){
                if(right1 != nullptr && right2 != nullptr){
                    TreeNode* right = new TreeNode(right1->val+right2->val);
                    node->right = right;
                    q.push(right);
                    que1.push(right1);
                    que2.push(right2);
                }else if(right1 != nullptr){
                    node->right = right1;
                }else if(right2 != nullptr){
                    node->right = right2;
                }
            }
            
        }
        return merge;

    }
};

PS:显然在使用递归的深度优先遍历实现的代码其可读性更强，同时代码的书写量也会少很多。