Leetcode 每日一题——116. 填充每个节点的下一个右侧节点指针

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

这道题拿到手第一反应就是用队列数据结构对二叉树进行广度优先搜索，所以最开始我就用C++实现了这个代码：

/*
// 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;
        queue<Node*> my_queue;
        my_queue.push(root);
        int queueSize=1;
        while(!my_queue.empty())
        {
            while(queueSize)
            {
                Node* tmp=my_queue.front();
                my_queue.pop();
                queueSize--;
                if(queueSize) tmp->next=my_queue.front();
                if(tmp->left) my_queue.push(tmp->left);
                if(tmp->right) my_queue.push(tmp->right);
            }
            queueSize=my_queue.size();
        }
        return root;
    }
};

运行效果：

此时的时间复杂度是O(N)，空间复杂度也为O(N)，类似的使用Python语言的collections.deque模块也可以实现，但是实际上本题还有个小提示：

那这么看，使用队列的层序遍历方法就有点不满足要求了（于是我参考了一下答案）。其实这道题目需要结合完美二叉树的结构特性进行编程，具体代码如下：

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        leftNode=root
        while leftNode.left:

            leftNode.left.next=leftNode.right

            nextNode=leftNode.next
            preNode=leftNode

            while(nextNode):
                preNode.right.next=nextNode.left
                nextNode.left.next=nextNode.right
                preNode=nextNode
                nextNode=nextNode.next

            leftNode=leftNode.left
        return root

这个方案也是层序遍历，只是它利用了每一层创建好的next指针，将每一层当成了一个链表，运行效果：

空间复杂度还是高，可能是我使用了一个前向节点的原因，这个思路实现的代码时间复杂度和BFS相同，但是空间复杂度为常数级O(1)。

来源：力扣（LeetCode）链接