力扣算法二叉树篇：合并二叉树

题解：

递归

前序遍历：
递归三部曲：
1、确定递归函数的参数和返回值
参数为合并的两棵树，返回值为合并之后的二叉树（根结点）
2、确定递归函数的终止条件
某一树为空时，返回另一个树
3、确定单层递归逻辑
合并树，从根结点开始，然后递归合并左右子树

/**
 * 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 == NULL){
            return root2;
        }
        if(root2 == NULL){
            return root1;
        }
        //单层递归 以第一棵树作为合并后的树
        root1->val +=root2->val;
        //左右子树
        root1->left = mergeTrees(root1->left,root2->left);
        root1->right = mergeTrees(root1->right,root2->right);
        return root1;
    }
};

中序遍历：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
          if(root1 == NULL){
            return root2;
        }
        if(root2 == NULL){
            return root1;
        }
         //左
        root1->left = mergeTrees(root1->left,root2->left);
        //中
        root1->val +=root2->val;
        //右
        root1->right = mergeTrees(root1->right,root2->right);
        return root1;
    }
};

后序遍历：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
          if(root1 == NULL){
            return root2;
        }
        if(root2 == NULL){
            return root1;
        }
         //左
        root1->left = mergeTrees(root1->left,root2->left);
        //右
        root1->right = mergeTrees(root1->right,root2->right);
        //中
        root1->val +=root2->val;
        return root1;
    }
};

迭代

层序遍历：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == NULL){
            return root2;
        }
        if(root2 == NULL){
            return root1;
        }
         //迭代法 层序遍历
         queue<TreeNode*> que;
         //根结点入队
         que.push(root1);
         que.push(root2);
         //遍历
         while(!que.empty()){
             //处理结点 不为空（下面会限制）
             TreeNode* node1 = que.front();
             que.pop();
             TreeNode* node2 = que.front();
             que.pop();
             node1->val +=node2->val;
             // 限制不空结点加入队列
             if(node1->left&& node2->left){
                 que.push(node1->left);
                 que.push(node2->left);
             }
             if(node1->right&& node2->right){
                 que.push(node1->right);
                 que.push(node2->right);
             }
             //如果第一棵树的左节点为空  另一棵树的左节点不为空
             if(node1->left == NULL && node2->left!=NULL){
                 node1->left = node2->left;
             }
             //如果第一棵树的右节点为空 另一棵树的右节点不为空
             if(node1->right == NULL && node2->right!=NULL){
                 node1->right = node2->right;
             }
         }
         return root1;
    }
};