給定一個二叉樹

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
}