LeetCode:117. 填充每个节点的下一个右侧节点指针 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 所示。序列化输出按层序遍历顺序（由 next 指针连接），’#’ 表示每层的末尾。

提示：

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

方法一：
直接层序遍历，使用一个队列存储节点，为了方便标记每层的节点数，设置变量l，r标记队列当前的位置，last标记每层的最后一个节点位置。

"""
# 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':
        import collections
        queue = collections.deque()
        def BFS(root):
            if root ==None:
                return
            queue.append(root)
			##l，r标记当前队列的起点和终点，last标记每层的末尾位置
            l, r, last = 0, 1, 1
            while len(queue) > 0:
                p = queue.popleft()
                l += 1
                if l != last and len(queue) > 0:
                    p.next = queue[0]

                if p.left:
                    queue.append(p.left)
                    r += 1
                if p.right:
                    queue.append(p.right)
                    r += 1
                ##每当l到达每层的末尾时，更新last
                if l == last:
                    last = r
        BFS(root)
        return root

时间复杂度：O(N)
空间复杂度：O(N)

方法二：

依然采用层序遍历的思想，只不过不再使用队列存储节点，而是借用next指针，进行层序遍历，在遍历当前层的同时，把下层节点串起来，如此迭代。
注意：为了统一操作，需要在下层节点起始处，添加一个头部节点，标记为dummy。

"""
# 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 root ==None:
            return
        cur= root
        
        while cur !=None:    
        	##起始节点，统一操作          
            dummy = Node(-9999)        
            pre = dummy
            while cur != None:                 
                if cur.left:
                    pre.next = cur.left
                    pre = cur.left
                if cur.right:
                    pre.next = cur.right
                    pre = cur.right
                cur = cur.next
            cur = dummy.next
        return root

时间复杂度：O(N)
空间复杂度：O(1)