leetcode 合并二叉树

617. 合并二叉树

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

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

示例 1:

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-binary-trees。

• 深度优先搜索
  递归的遍历两颗原始树的相同位置。

/**
 * 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* result = new TreeNode(root1->val + root2->val);
        result->left = mergeTrees(root1->left, root2->left);
        result->right = mergeTrees(root1->right, root2->right);
        return result;
    }
};

• 广度优先搜索
  与深度优先搜索思路一致，依次找出原始树中对应的节点，如果原始树中都存在，则加到队列中继续遍历，否则该节点后面直接将存在的原始节点复制到合并后的节点即可。

/**
 * 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* result = new TreeNode(root1->val + root2->val);
        std::queue<TreeNode*> que_re;
        std::queue<TreeNode*> que_root1;
        std::queue<TreeNode*> que_root2;
        que_re.emplace(result);
        que_root1.emplace(root1);
        que_root2.emplace(root2);
        while (!que_root2.empty() && !que_root2.empty()) {
            auto re = que_re.front();
            que_re.pop();
            auto r1 = que_root1.front();
            que_root1.pop();
            auto r2 = que_root2.front();
            que_root2.pop();
            if (r1->left || r2->left) {
                if (r1->left && r2->left) {
                    re->left = new TreeNode(r1->left->val + r2->left->val);
                    que_re.emplace(re->left);
                    que_root1.emplace(r1->left);
                    que_root2.emplace(r2->left);
                } else if (r1->left) {
                    re->left = r1->left;
                } else {
                    re->left = r2->left;
                }
            }
            if (r1->right || r2->right) {
                if (r1->right && r2->right) {
                    re->right = new TreeNode(r1->right->val + r2->right->val);
                    que_re.emplace(re->right);
                    que_root1.emplace(r1->right);
                    que_root2.emplace(r2->right);
                } else if (r1->right) {
                    re->right = r1->right;
                } else {
                    re->right = r2->right;
                }
            }
        }
        return result;
    }
};