简单递归+层序遍历（记录层数） 116. 填充每个节点的下一个右侧节点指针 117. 填充每个节点的下一个右侧节点指针 II

本文链接：https://blog.youkuaiyun.com/BLUEsang/article/details/106213260

本文介绍了两种方法实现填充二叉树每个节点的下一个右侧节点指针：一是通过递归方式，二是利用层序遍历并记录层数。在层序遍历的优化中，通过Q.front()避免了使用额外的pre变量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

递归实现填充节点

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        root->next=NULL;
        getnext(root->left,root->right);
        return root;
    }
private:
    void getnext(Node* a,Node * b){
        if(!a||!b) return;
        a->next=b;
        getnext(a->left,a->right);
        getnext(a->right,b->left);
        getnext(b->left,b->right);
        return;
    } 
};

层序遍历实现填充节点
（1）记录每层尾指针实现记录层数的层序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        Q.push(root);
        Node * end=root;
        Node * cur;
        Node * pre=end;
        while(!Q.empty()){
            Node* tmp=Q.front();
            Q.pop();
            if(tmp->left){
                Q.push(tmp->left);
                cur=tmp->left;
            }
            if(tmp->right){
                Q.push(tmp->right);
                cur=tmp->right;
            }

            if(tmp==end) {
                if(pre)
                pre->next=tmp;
                tmp->next=NULL;
                end=cur;
                pre=NULL;
            }
            else {
            if(pre)
            pre->next=tmp;
            pre=tmp; 
            }
        }
        return root;
    }
private:
    queue<Node* > Q;
};

（2）记录每层大小实现记录层数的层序遍历


class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        Q.push(root);
        Node *tmp;
        Node *pre=NULL;
        while(!Q.empty()){
            int size=Q.size();
            while(size--){
            tmp=Q.front();
            Q.pop();
            if(pre) pre->next=tmp;
            if(!size) tmp->next=NULL;
            if(tmp->left)
            Q.push(tmp->left);
            if(tmp->right)
            Q.push(tmp->right);
            pre=tmp;
            }
            pre=NULL;
        }
        return root;
    }
private:
    queue<Node* > Q;
};

优化：利用Q.front()省去pre变量；

class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        Q.push(root);
        Node *tmp;
        while(!Q.empty()){
           int size=Q.size();
           while(size--){
           tmp=Q.front();
           Q.pop();
           if(size) tmp->next=Q.front();
           else tmp->next=NULL;
           if(tmp->left) Q.push(tmp->left);
           if(tmp->right) Q.push(tmp->right);
           }
        }
        return root;
    }
private:
    queue<Node* > Q;
};