Wong Kosheng1. 题目背景与需求解析
PTA（Programming Teaching Assistant）是中国高校广泛使用的程序设计类课程辅助教学平台，其中L2-051题目要求实现满二叉树的特定遍历方式。满二叉树是指所有非叶子节点都有两个子节点，且所有叶子节点都在同一层的二叉树结构。
这道题目的核心考察点在于：
- 对二叉树结构的理解与构建能力
- 非递归遍历算法的实现技巧
- C++标准模板库(STL)中容器类的灵活运用
- 边界条件的处理能力
在实际工程中，树形结构的遍历是文件系统操作、DOM树处理、路由算法等场景的基础。例如在游戏开发中，场景图(Scene Graph)就是典型的树形结构，角色的移动和碰撞检测都需要高效的遍历算法。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 数据结构设计与构建
2.1 二叉树节点定义
我们采用经典的链式存储结构表示二叉树节点：
cpp复制struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
这种设计在内存使用效率和时间复杂度之间取得了良好平衡。每个节点存储：
- val：节点值（题目中通常是整数）
- left/right：智能指针或原生指针实现子节点引用
注意：实际工程中建议使用unique_ptr等智能指针，但PTA环境通常只支持C++11基础功能。
2.2 满二叉树的构建方法
对于满二叉树，可以采用递归构建方式：
cpp复制TreeNode* buildFullTree(int depth, int& counter) {
if (depth == 0) return nullptr;
TreeNode* node = new TreeNode(++counter);
node->left = buildFullTree(depth - 1, counter);
node->right = buildFullTree(depth - 1, counter);
return node;
}
调用示例：
cpp复制int counter = 0;
TreeNode* root = buildFullTree(3, counter); // 构建3层满二叉树
构建时间复杂度为O(2^n)，空间复杂度O(n)（递归栈深度）。
3. 核心遍历算法实现
3.1 层序遍历（BFS实现）
层序遍历是本题的基础要求，使用队列实现：
cpp复制void levelOrder(TreeNode* root) {
if (!root) return;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
cout << node->val << " ";
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
}
时间复杂度O(n)，空间复杂度O(w)（w为树的最大宽度）。
3.2 锯齿形层序遍历
本题的进阶要求是锯齿形（之字形）遍历：
cpp复制vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> result;
if (!root) return result;
queue<TreeNode*> q;
q.push(root);
bool leftToRight = true;
while (!q.empty()) {
int levelSize = q.size();
vector<int> currentLevel(levelSize);
for (int i = 0; i < levelSize; ++i) {
TreeNode* node = q.front();
q.pop();
int index = leftToRight ? i : levelSize - 1 - i;
currentLevel[index] = node->val;
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
result.push_back(currentLevel);
leftToRight = !leftToRight;
}
return result;
}
关键点：
- 使用队列进行常规BFS
- 根据当前方向决定节点值的存储位置
- 每层结束后反转遍历方向
3.3 其他遍历方式的对比
| 遍历方式 | 实现方法 | 时间复杂度 | 空间复杂度 | 应用场景 |
|---|---|---|---|---|
| 前序 | 递归/栈 | O(n) | O(h) | 复制树结构 |
| 中序 | 递归/栈 | O(n) | O(h) | 二叉搜索树排序 |
| 后序 | 递归/栈 | O(n) | O(h) | 释放树内存 |
| 层序 | 队列 | O(n) | O(w) | 查找最短路径 |
| 锯齿形 | 队列+方向控制 | O(n) | O(w) | 图形化展示 |
4. 完整代码实现与解析
cpp复制#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* buildFullTree(int depth, int& counter) {
if (depth == 0) return nullptr;
TreeNode* node = new TreeNode(++counter);
node->left = buildFullTree(depth - 1, counter);
node->right = buildFullTree(depth - 1, counter);
return node;
}
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> result;
if (!root) return result;
queue<TreeNode*> q;
q.push(root);
bool leftToRight = true;
while (!q.empty()) {
int levelSize = q.size();
vector<int> currentLevel(levelSize);
for (int i = 0; i < levelSize; ++i) {
TreeNode* node = q.front();
q.pop();
int index = leftToRight ? i : levelSize - 1 - i;
currentLevel[index] = node->val;
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
result.push_back(currentLevel);
leftToRight = !leftToRight;
}
return result;
}
int main() {
int depth;
cin >> depth;
int counter = 0;
TreeNode* root = buildFullTree(depth, counter);
vector<vector<int>> result = zigzagLevelOrder(root);
for (const auto& level : result) {
for (int val : level) {
cout << val << " ";
}
cout << endl;
}
return 0;
}
代码解析：
- 输入处理：读取树的高度depth
- 树构建：使用递归方式构建满二叉树
- 遍历执行：实现锯齿形层序遍历
- 结果输出：按层打印节点值
5. 常见问题与调试技巧
5.1 内存泄漏问题
在PTA等OJ系统中，虽然小规模数据不会立即显现内存泄漏问题，但良好的习惯很重要：
cpp复制void deleteTree(TreeNode* root) {
if (!root) return;
deleteTree(root->left);
deleteTree(root->right);
delete root;
}
在main函数结束前调用：
cpp复制deleteTree(root);
5.2 特殊输入处理
需要考虑的边界情况：
- depth = 0（空树）
- depth = 1（只有根节点）
- 大depth值（测试递归深度限制）
5.3 性能优化建议
- 对于大规模树，可改用迭代方式构建：
cpp复制TreeNode* buildFullTreeIterative(int depth) {
if (depth == 0) return nullptr;
int nodeCount = (1 << depth) - 1;
vector<TreeNode*> nodes(nodeCount);
for (int i = 0; i < nodeCount; ++i) {
nodes[i] = new TreeNode(i + 1);
}
for (int i = 0; i < nodeCount/2; ++i) {
nodes[i]->left = nodes[2*i+1];
nodes[i]->right = nodes[2*i+2];
}
return nodes[0];
}
- 锯齿形遍历的方向控制可以改用双端队列(deque)实现：
cpp复制vector<vector<int>> zigzagWithDeque(TreeNode* root) {
vector<vector<int>> result;
if (!root) return result;
deque<TreeNode*> dq;
dq.push_back(root);
bool leftToRight = true;
while (!dq.empty()) {
int levelSize = dq.size();
vector<int> currentLevel;
for (int i = 0; i < levelSize; ++i) {
if (leftToRight) {
TreeNode* node = dq.front();
dq.pop_front();
currentLevel.push_back(node->val);
if (node->left) dq.push_back(node->left);
if (node->right) dq.push_back(node->right);
} else {
TreeNode* node = dq.back();
dq.pop_back();
currentLevel.push_back(node->val);
if (node->right) dq.push_front(node->right);
if (node->left) dq.push_front(node->left);
}
}
result.push_back(currentLevel);
leftToRight = !leftToRight;
}
return result;
}
6. 实际应用场景扩展
二叉树遍历在以下场景中有重要应用：
- 文件系统导航：Unix的
tree命令就是基于深度优先遍历 - DOM树操作：浏览器渲染引擎需要遍历DOM树计算样式
- 游戏场景图：角色和物体的空间关系通常用树结构管理
- 路由算法：网络路由表常用前缀树(Trie)结构存储
以游戏场景为例，典型的更新循环包含：
cpp复制void updateScene(TreeNode* node) {
if (!node) return;
// 更新当前节点代表的游戏对象
updateGameObject(node->val);
// 递归更新子节点
updateScene(node->left);
updateScene(node->right);
}
在真实项目中，我们还需要考虑：
- 遍历中断机制（如发现碰撞时停止）
- 并行化遍历（对子树多线程处理）
- 增量式遍历（部分更新）