LeetCode树——填充每个节点的下一个右侧节点指针 II

题目描述

给定一个二叉树

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

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

提示：

树中的节点数小于 6000
-100 <= node.val <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

这一题首先想到的解法是层次遍历，但按照传统的层次遍历，不能区分某层有哪些节点，因此要在原来的层次遍历的基础上，做出少许改动。

即将原来按节点的循环，改造成为按照层的循环，在while循环里，嵌套一层for循环，在for循环里，遍历该层的所有节点，并修改next节点。

代码如下：

/*
// 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) {
        queue<Node*> q;
        if(root ==NULL) //判断根节点是否为空
            return root;
        q.push(root);
        int i;
        Node* tem1;//这里其实踩了一个小坑，刚开始的时候直接Node*tem1,tem2;最后报错才发现tem2的类型错误。
        Node* tem2;
        while(!q.empty()){
            int qsize = q.size();
            tem1 = q.front();//记录前一个节点
            for(i=0;i<qsize;i++){ //按层遍历
                tem2 = q.front();
                if(tem2->left != NULL){//把下一层的节点push进队列中
                    q.push(tem2->left);
                }
                if(tem2->right != NULL){
                    q.push(tem2->right);
                }
                if(i>0){//当节点非第一个节点时，修改节点的next
                    tem1->next = tem2;
                }
                tem1 = tem2;//更新前一个节点
                q.pop();

            }

        }
        return root;
        
    }
};

最后运行的结果挺一般的：

官方题解学习

官方题解中除了第一种做法外，还利用next指针降低了空间复杂度。即官方文档没有使用队列，而是先在上一层搭建next指针，利用next指针实现对树的遍历。
这里看到了一个超过100%的实现方法，明天撸一下，在寝室的学习效率还是太低了哭！

/*
// 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:
    void handle(Node* &laststart,Node* &nextstart,Node* &start){
        if(laststart != NULL){
            laststart->next = nextstart;
        }
        else{
            start = nextstart;
        }
        laststart = nextstart;
    }

    Node* connect(Node* root) {
        Node* ln,* nextstart,*laststart;
        Node* start = root;
        while(start!=NULL){
            nextstart=NULL;
            laststart=NULL;
            ln=start;
            for(start=NULL;ln!=NULL;ln=ln->next){
                if(ln->left != NULL){
                      nextstart = ln->left;
                      handle(laststart,nextstart,start);
                }
                if(ln->right != NULL){
                      nextstart = ln->right;
                      handle(laststart,nextstart,start);
                }
            }
        }
        return root;
        
    }
};