(118)117. 填充每个节点的下一个右侧节点指针 II(leetcode)

题目链接：
https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/
难度：中等
117. 填充每个节点的下一个右侧节点指针 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

还是比较简单的 如果不考虑进阶的话。。。。
思路很简单，广度遍历就可以了 直接过 当然还需要一个last用来存储上一个节点

/*
// 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==nullptr){
            return root;
        }
        queue<Node*> que;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            Node* last=nullptr;
            for(int i=0;i<size;++i){
                auto t=que.front();
                que.pop();
                if(last!=nullptr){
                    last->next=t;
                }else if(i==size-1){
                    t->next=nullptr;
                }
                last=t;
                if(t->left!=nullptr){
                    que.push(t->left);
                }
                if(t->right!=nullptr){
                    que.push(t->right);
                }
            }
        }
        return root;
    }
};

没想到这个方法和答案是一样的。。。

考虑进阶的话 使用常数级的空间复杂度 额 这个没想出来 还是菜啊 看了看题解 还是挺好理解的
从根节点开始 在第 i 层对第 i+1 层进行操作

class Solution {
public:
    Node* connect(Node* root) {
        if(root==nullptr){
            return root;
        }
        queue<Node*> que;
        // 当前开始的节点
        Node* curstart=root;
        while(curstart){
        	// 上一个节点
            Node* last=nullptr;
            // 记录下一个开始的节点
            // 第i+1层的最左侧节点
            Node* nextstart=nullptr;
            // 对该层节点进行枚举
            // 在一个for中 只有第一次才会对nextstart赋值
            for(auto p=curstart;p!=nullptr;p=p->next){
            	// last 第i+1层的上一个节点
                if(p->left!=nullptr){
                    if(last!=nullptr){
                        last->next=p->left;
                    }
                    last=p->left;
                    if(nextstart==nullptr){
                        nextstart=p->left;
                    }
                }
                if(p->right!=nullptr){
                    if(last!=nullptr){
                        last->next=p->right;
                    }
                    last=p->right;
                    if(nextstart==nullptr){
                        nextstart=p->right;
                    }
                }
            }
            curstart=nextstart;
        }
        return root;
    }
};