leetcode-116. 填充每个节点的下一个右侧节点指针

题目

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

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

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

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

示例：

输入：{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":null,"right":null,"val":4},"next":null,"right":{"$id":"4","left":null,"next":null,"right":null,"val":5},"val":2},"next":null,"right":{"$id":"5","left":{"$id":"6","left":null,"next":null,"right":null,"val":6},"next":null,"right":{"$id":"7","left":null,"next":null,"right":null,"val":7},"val":3},"val":1}

输出：{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":{"$id":"4","left":null,"next":{"$id":"5","left":null,"next":{"$id":"6","left":null,"next":null,"right":null,"val":7},"right":null,"val":6},"right":null,"val":5},"right":null,"val":4},"next":{"$id":"7","left":{"$ref":"5"},"next":null,"right":{"$ref":"6"},"val":3},"right":{"$ref":"4"},"val":2},"next":null,"right":{"$ref":"7"},"val":1}

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

解题思路

层次遍历呗，碰到最右边的节点时，next指向空即可。非最右节点，next指向队列头的节点。时间复杂度是o(n)，空间复杂度也是o(n)

常数级空间解法
递归版：
层次遍历实际上没有使用perfect tree的特性，看了官解想到的思路。

对于上面建立next的过程，其实next可以分成2种边，第一种是上图4到5的边，可以直接用root.left.next = root.right，第二种是上图5到6的边，因为2的next已经建立好，所以可以用root.right.next = root.next.left来建立。

整个是一个递归的过程。

非递归版：
当需要对第3层建立next链接时，第2层的next链接已经建立好，此时光看第2层的节点的话，其实就像一条链表一样了。用一个变量保存每个链表的头，然后遍历整条链表，调整链表节点对应的子节点next，遍历完毕后，移动到下一层链表上再继续即可。

代码

"""
# 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
        deque = collections.deque([root])
        right = root
        while deque:
            node = deque.popleft()
            if node.left:
                deque.append(node.left)
                deque.append(node.right)
            if node == right:
                if deque:
                    right = deque[-1]
                node.next = None
            else:
                node.next = deque[0]
        return root

常数级空间
递归版：

"""
# 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':
        def helper(root: 'Node') -> 'Node':
            if (not root) or (not root.left):
                return root
            root.left.next = root.right
            if root.next:
                root.right.next = root.next.left
            helper(root.left)
            helper(root.right)
            return root
        return helper(root)

非递归版：

"""
# 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
        start = root
        while start.left:
            head = start
            while head:
                head.left.next = head.right
                if head.next:
                    head.right.next = head.next.left
                head = head.next
            start = start.left
        return root