給定一個完美二叉樹，其所有葉子節點都在同一層，每個父節點都有兩個子節點。二叉樹定義如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每個 next 指標，讓這個指標指向其下一個右側節點。如果找不到下一個右側節點，則將 next 指標設定為 NULL。

初始狀態下，所有next 指標都被設定為 NULL。

進階：

你只能使用常量級額外空間。
使用遞迴解題也符合要求，本題中遞迴程式佔用的棧空間不算做額外的空間複雜度。

示例：

輸入：root = [1,2,3,4,5,6,7]
輸出：[1,#,2,3,#,4,5,6,7,#]
解釋：給定二叉樹如圖 A 所示，你的函式應該填充它的每個 next 指標，以指向其下一個右側節點，如圖 B 所示。序列化的輸出按層序遍歷排列，同一層節點由 next 指標連線，'#' 標誌著每一層的結束。

提示：

樹中節點的數量少於4096
-1000 <= node.val <= 1000

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node

python

# 0116.填充每個節點的下一個右側節點指標
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:
        """
        迭代法, list解法
        :param root:
        :return:
        """
        if not root:
            return None

        queue = [root]
        while queue:
            n = len(queue)
            for i in range(n):
                node = queue.pop(0)
                if node.left: # 新增節點的左子節點入隊
                    queue.append(node.left)
                if node.right: # 新增節點的右子節點入隊
                    queue.append(node.right)
                if i == n-1: # 當前層的最後節點時
                    break
                # 新增next指標，指向下個右側節點，如當層序號1->2->3->4->...->n->None，每個節點指標預設None
                node.next = queue[0]

        return root

class Solution1:
    def connect(self, root: Node) -> Node:
        """
        迭代法，連結串列解法
        :param root:
        :return:
        """
        first = root
        while first:
            cur = first
            while cur: # 遍歷每層節點
                if cur.left: # 左節點next
                    cur.left.next = cur.right
                if cur.right and cur.next: # 右節點的next
                    cur.right.next = cur.next.left
                cur = cur.next # cur移動到同層的next
            first = first.left # 從本層到下一層，每次從同層第一個節點開始next指標指向
        return root
 

golang

package binaryTree

import "container/list"

type Node struct {
	Val int
	Left, Right, Next *Node
}

func connect(root *Node) *Node {
	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
}