LeetCode 第116题：填充每个节点的下一个右侧节点指针
题目描述
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
难度
中等
题目链接
示例
示例 1：
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
提示
- 树中节点的数量在
[0, 2^12 - 1]范围内 -1000 <= node.val <= 1000
解题思路
方法一：层序遍历（BFS）
最直观的方法是使用层序遍历（广度优先搜索）。我们可以按层遍历二叉树，对于每一层的节点，将它们依次连接起来。
关键点：
- 使用队列进行层序遍历
- 对于每一层，依次连接节点的next指针
- 每层结束时，最后一个节点的next指针设为NULL
具体步骤：
- 如果根节点为空，直接返回
- 初始化队列，将根节点入队
- 当队列不为空时，执行以下操作： a. 获取当前层的节点数量 b. 遍历当前层的所有节点 c. 对于每个节点，如果它不是当前层的最后一个节点，将其next指针指向队列中的下一个节点 d. 将当前节点的左右子节点（如果存在）入队
- 返回根节点
时间复杂度：O(n)，其中n是树中节点的数量，每个节点只会被访问一次 空间复杂度：O(n)，队列中最多存储n/2个节点（最后一层的节点数量）
方法二：利用已建立的next指针（常数空间）
由于题目给定的是完美二叉树，我们可以利用已经建立好的next指针来实现常数空间的解法。
关键点：
- 从根节点开始，逐层处理
- 对于每一层，使用已建立的next指针横向遍历
- 同时为下一层建立next指针
具体步骤：
- 如果根节点为空，直接返回
- 初始化leftmost指针指向每一层的最左节点，初始为根节点
- 当leftmost不为空时，执行以下操作： a. 初始化curr指针为当前层的leftmost b. 当curr不为空时： i. 将curr的左子节点的next指针指向curr的右子节点 ii. 如果curr的next不为空，将curr的右子节点的next指针指向curr的next的左子节点 iii. 将curr指针移动到next节点 c. 将leftmost指针移动到下一层的最左节点（即当前leftmost的左子节点）
- 返回根节点
时间复杂度：O(n)，每个节点只会被访问一次 空间复杂度：O(1)，只使用了常数额外空间
图解思路
方法一：层序遍历过程
| 层数 | 队列状态 | 操作 | 结果 |
|---|---|---|---|
| 1 | [1] | 1.next = NULL | 1 -> NULL |
| 2 | [2, 3] | 2.next = 3, 3.next = NULL | 2 -> 3 -> NULL |
| 3 | [4, 5, 6, 7] | 4.next = 5, 5.next = 6, 6.next = 7, 7.next = NULL | 4 -> 5 -> 6 -> 7 -> NULL |
方法二：利用已建立的next指针过程
| 当前节点 | 操作 | 结果 |
|---|---|---|
| 1 | 1.left.next = 1.right, 1.right.next = NULL | 2 -> 3 -> NULL |
| 2 | 2.left.next = 2.right, 2.right.next = 2.next.left | 4 -> 5 -> 6 |
| 3 | 3.left.next = 3.right, 3.right.next = NULL | 6 -> 7 -> NULL |
代码实现
C# 实现
/*
// Definition for a Node.
public class Node {
public int val;
public Node left;
public Node right;
public Node next;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, Node _left, Node _right, Node _next) {
val = _val;
left = _left;
right = _right;
next = _next;
}
}
*/
public class Solution {
// 方法一：层序遍历（BFS）
public Node Connect(Node root) {
if (root == null) {
return null;
}
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(root);
while (queue.Count > 0) {
int size = queue.Count;
for (int i = 0; i < size; i++) {
Node node = queue.Dequeue();
// 如果不是当前层的最后一个节点，设置next指针
if (i < size - 1) {
node.next = queue.Peek();
}
// 将子节点加入队列
if (node.left != null) {
queue.Enqueue(node.left);
}
if (node.right != null) {
queue.Enqueue(node.right);
}
}
}
return root;
}
// 方法二：利用已建立的next指针（常数空间）
public Node ConnectOptimized(Node root) {
if (root == null) {
return null;
}
// leftmost指向每一层的最左节点
Node leftmost = root;
// 当leftmost的左子节点不为空时，说明还有下一层
while (leftmost.left != null) {
// 从当前层的最左节点开始，通过next指针遍历当前层
Node curr = leftmost;
while (curr != null) {
// 连接左子节点和右子节点
curr.left.next = curr.right;
// 如果curr有next节点，连接curr的右子节点和curr.next的左子节点
if (curr.next != null) {
curr.right.next = curr.next.left;
}
// 移动到当前层的下一个节点
curr = curr.next;
}
// 移动到下一层的最左节点
leftmost = leftmost.left;
}
return root;
}
}
Python 实现
"""
# 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:
# 方法一：层序遍历（BFS）
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return None
queue = collections.deque([root])
while queue:
size = len(queue)
for i in range(size):
node = queue.popleft()
# 如果不是当前层的最后一个节点，设置next指针
if i < size - 1:
node.next = queue[0]
# 将子节点加入队列
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return root
# 方法二：利用已建立的next指针（常数空间）
def connectOptimized(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return None
# leftmost指向每一层的最左节点
leftmost = root
# 当leftmost的左子节点不为空时，说明还有下一层
while leftmost.left:
# 从当前层的最左节点开始，通过next指针遍历当前层
curr = leftmost
while curr:
# 连接左子节点和右子节点
curr.left.next = curr.right
# 如果curr有next节点，连接curr的右子节点和curr.next的左子节点
if curr.next:
curr.right.next = curr.next.left
# 移动到当前层的下一个节点
curr = curr.next
# 移动到下一层的最左节点
leftmost = leftmost.left
return root
C++ 实现
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node* next;
Node() : val(0), left(NULL), right(NULL), next(NULL) {}
Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
Node(int _val, Node* _left, Node* _right, Node* _next)
: val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
// 方法一：层序遍历（BFS）
Node* connect(Node* root) {
if (root == nullptr) {
return nullptr;
}
queue<Node*> q;
q.push(root);
while (!q.empty()) {
int size = q.size();
for (int i = 0; i < size; i++) {
Node* node = q.front();
q.pop();
// 如果不是当前层的最后一个节点，设置next指针
if (i < size - 1) {
node->next = q.front();
}
// 将子节点加入队列
if (node->left != nullptr) {
q.push(node->left);
}
if (node->right != nullptr) {
q.push(node->right);
}
}
}
return root;
}
// 方法二：利用已建立的next指针（常数空间）
Node* connectOptimized(Node* root) {
if (root == nullptr) {
return nullptr;
}
// leftmost指向每一层的最左节点
Node* leftmost = root;
// 当leftmost的左子节点不为空时，说明还有下一层
while (leftmost->left != nullptr) {
// 从当前层的最左节点开始，通过next指针遍历当前层
Node* curr = leftmost;
while (curr != nullptr) {
// 连接左子节点和右子节点
curr->left->next = curr->right;
// 如果curr有next节点，连接curr的右子节点和curr.next的左子节点
if (curr->next != nullptr) {
curr->right->next = curr->next->left;
}
// 移动到当前层的下一个节点
curr = curr->next;
}
// 移动到下一层的最左节点
leftmost = leftmost->left;
}
return root;
}
};
执行结果
C# 实现
- 执行用时：96 ms
- 内存消耗：40.2 MB
Python 实现
- 执行用时：52 ms
- 内存消耗：16.4 MB
C++ 实现
- 执行用时：16 ms
- 内存消耗：16.8 MB
性能对比
| 语言 | 执行用时 | 内存消耗 | 特点 |
|---|---|---|---|
| C# | 96 ms | 40.2 MB | 代码结构清晰，但性能较慢 |
| Python | 52 ms | 16.4 MB | 代码简洁，性能适中 |
| C++ | 16 ms | 16.8 MB | 执行速度最快，内存占用适中 |
代码亮点
- 🎯 方法二利用完美二叉树的特性，实现了O(1)空间复杂度的解法
- 💡 巧妙利用已建立的next指针进行横向遍历，避免了使用队列
- 🔍 正确处理了边界情况，如空树和每层最后一个节点
- 🎨 两种方法各有优势，BFS适用于一般二叉树，优化方法适用于完美二叉树
常见错误分析
- 🚫 忽略了题目中完美二叉树的特性，使用了不必要的复杂解法
- 🚫 没有正确处理每层最后一个节点的next指针
- 🚫 在方法二中，没有正确利用已建立的next指针进行横向遍历
- 🚫 忘记检查节点是否为空，导致空指针异常
解法对比
| 解法 | 时间复杂度 | 空间复杂度 | 优点 | 缺点 |
|---|---|---|---|---|
| 层序遍历（BFS） | O(n) | O(n) | 通用性强，适用于任何二叉树 | 需要额外空间存储队列 |
| 利用next指针 | O(n) | O(1) | 空间效率高 | 仅适用于完美二叉树 |
