Leetcode学习计划-算法入门第8天

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

方案：采用两种方法，第一是深度优先搜索，第二种是广度优先搜索，广度优先搜索中需要三个队列。

DFS:

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr)return root2;
        if(root2==nullptr)return root1;
        TreeNode* ans=new TreeNode(root1->val+root2->val);
        ans->left=mergeTrees(root1->left,root2->left);
        ans->right=mergeTrees(root1->right,root2->right);
        return ans;
    }
};

BFS：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr)return root2;
        if(root2==nullptr)return root1;
        TreeNode* merged=new TreeNode(root1->val+root2->val);
        queue<TreeNode*>que1;
        queue<TreeNode*>que2;
        queue<TreeNode*>que;
        que1.push(root1);
        que2.push(root2);
        que.push(merged);
        while(!que1.empty()&&!que2.empty()){
            TreeNode* node=que.front(),*node1=que1.front(),*node2=que2.front();
            que.pop();
            que1.pop();
            que2.pop();
            TreeNode* left1=node1->left,*left2=node2->left,*right1=node1->right,*right2=node2->right;
            if(left1||left2){
                if(left1&&left2){
                TreeNode* left=new TreeNode(left1->val+left2->val);
                node->left=left;
                que.push(left);
                que1.push(left1);
                que2.push(left2);
                }
                else if(left1){
                    node->left=left1;
                }
                else{
                    node->left=left2;
                }
            }
            if(right1||right2){
                if(right1&&right2){
                TreeNode* right=new TreeNode(right1->val+right2->val);
                node->right=right;
                que.push(right);
                que1.push(right1);
                que2.push(right2);
                }
                else if(right1){
                    node->right=right1;
                }
                else{
                    node->right=right2;
                }
            }
            
        }
        return merged;
    }
};

题目：给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

方案：使用广度优先搜索、层次遍历。

class Solution {
public:
    Node* connect(Node* root) {
        if(!root)return root;
        queue<Node*>que;
        que.push(root);
        while(!que.empty()){
            int size=que.size(); #计数
            for(int i=0;i<size;i++){
                Node* node=que.front();
                que.pop();
                if(i<size-1){
                    node->next=que.front();
                }
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }

        }
        return root;
    }
};

#因为是完全二叉树，左节点和右节点都同时存在
class Solution {
public:
    Node* connect(Node* root) {
        if(!root)return root;
        
        queue<Node*>que;
        que.push(root);
        
        while(!que.empty()){
            Node* node=que.front();
            que.pop();
            Node* left=node->left,*right=node->right;
            if(left&&right){
                left->next=right;
                que.push(left);
                que.push(right);
                while(node->next!=NULL){
                    node->right->next=node->next->left;
                    node=node->next;
                }
            }
            
        }
        return root;
    }
};

来源：力扣（LeetCode）

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。