填充每个节点的下一个右侧节点指针（LeetCode）

题目

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

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

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

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

解题

class Node:
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next


def connect(root):
    if not root:
        return None

    leftmost = root

    while leftmost.left:
        head = leftmost

        while head:
            head.left.next = head.right

            if head.next:
                head.right.next = head.next.left

            head = head.next

        leftmost = leftmost.left

    return root


# 辅助函数，用于生成完美二叉树
def build_perfect_tree(vals):
    if not vals:
        return None
    nodes = [Node(val) if val is not None else None for val in vals]
    for i in range(len(nodes)):
        if nodes[i] is not None:
            if 2 * i + 1 < len(nodes):
                nodes[i].left = nodes[2 * i + 1]
            if 2 * i + 2 < len(nodes):
                nodes[i].right = nodes[2 * i + 2]
    return nodes[0]


# 辅助函数，用于按层次输出节点值及其next指针，层次之间用#分隔
def level_order_with_next(root):
    if not root:
        return []

    result = []
    current = root
    while current:
        level = current
        while level:
            result.append(level.val)
            level = level.next
        result.append('#')
        current = current.left

    return result


# 示例测试
vals = [1, 2, 3, 4, 5, 6, 7]
root = build_perfect_tree(vals)
connect(root)
result = level_order_with_next(root)
print(result)  # 输出：[1, '#', 2, 3, '#', 4, 5, 6, 7, '#']