给定一个二叉树
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
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii
python
# 0117.填充每个节点的下一个右侧节点指针II
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:
"""
迭代法
思路：从 1,2层流程来看具体执行
- 1.初始时，queue仅根节点root
- 2.进入循环，取队列长度，控制当层循环次数，每层维护一个尾结点tail为None
- 3.遍历当前层，cur为当前queue的队头节点，pop,
- 4.检查tail，由于是根节点，tail对应应该是None, 把当前节点作为即root节点作为tail节点
- 5.如果cur节点左子节点非空，加入队列queue, 如果cur节点的右子节点非空，加入队列queue, 至此第一层已经遍历完，
此时queue应该依次存放根节点的左右节点， queue=[root.left, root.right], tail为root节点，初始化时，next指针为None
****开始第二层节点遍历****
- 6.不妨设根节点有左右子节点，即len=2
- 7.tail为None, 遍历当前层，先pop的为左子节点，由于tail 为None, 略过，重新令tail节点为2层的第1个节点root.left, 然后把该节点的左右子节点继续加入队尾，有的话
- 8.继续第2层的第2次遍历，cur此时应是root.right, 由于tail非空，tail.next指向root.right, 接下来重新把root.right赋给tail,
即tail指向了第二层的最后一个节点，接下来root.right的左右子节点入队，重复遍历第3层
next指针的填充操作：
tail初始指向每层的第一个节点，通过当tail非空的检查，将每层的节点的next指针不断向当前层的后续节点传递，最后tail指向该层的最后一个节点
:param root:
:return:
"""
if not root:
return None
queue = [root]
while queue: # 遍历每一层
length = len(queue)
tail = None # 每层维护一个节点
for i in range(length): # 遍历当前层
curNode = queue.pop(0) # 遍历当层时，每次取队头节点
if tail: # 完成next指针的填充
tail.next = curNode # 尾结点指向当前节点
tail = curNode # 当前节点成为尾结点
if curNode.left:
queue.append(curNode.left)
if curNode.right:
queue.append(curNode.right)
return root
class Solution1:
def connect(self, root: Node) -> Node:
if not root:
return None
first = root
while first:
dummyHead = Node(None) # 为下行创建虚拟头结点
tail = dummyHead # 初始化虚拟头结点
cur = first
while cur: # 遍历当前层节点
if cur.left:
tail.next = cur.left
tail = tail.next
if cur.right:
tail.next = cur.right
tail = tail.next
cur = cur.next # cur同层移动
first = dummyHead.next # 换行操作，更新到下一行
return root
golang
package binaryTree
import "container/list"
type Node struct {
Val int
Left, Right, Next *Node
}
func connect(root *Node) *Node {
var res = [][]*Node{}
if root == nil {
return root
}
queue := list.New()
queue.PushBack(root)
var tmpArr []*Node
for queue.Len() > 0 {
length := queue.Len() // 处理本层节点
for i:=0;i<length;i++ {
node := queue.Remove(queue.Front()).(*Node) // 头部节点出队列
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr = append(tmpArr, node)
}
res = append(res, tmpArr)
tmpArr = []*Node{} // 清空层数据
}
// 上面操作部分与层序遍历一致
// 下面操作，遍历每层元素，指定next
for i:=0;i<len(res);i++ {
for j:=0;j<len(res[i])-1;j++ { // 当层的最后一个不操作，默认指向nil
res[i][j].Next = res[i][j+1]
}
}
return root
}