1. 树与二叉树的基础概念解析
第一次接触树结构是在大二的数据结构课上，当时教授用家族谱系来比喻树的结构，这个生动的例子让我瞬间理解了这种非线性数据组织的精髓。树（Tree）是由n（n≥0）个节点组成的有限集合，当n=0时称为空树，否则满足以下条件：
- 有且仅有一个特定的称为根（Root）的节点
- 其余节点可分为m（m≥0）个互不相交的有限集合，每个集合本身又是一棵树，称为根的子树
二叉树（Binary Tree）是树结构的特例，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种限制看似简单，却带来了许多独特的性质：
c复制struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};
在蓝桥杯竞赛中，二叉树相关题目出现频率极高。以2021年省赛真题为例，要求选手计算二叉树中所有左叶子节点的和。这类题目考察的核心就是对二叉树遍历的理解和实现能力。
提示：理解递归是掌握二叉树操作的关键。每次处理节点时，都将其视为一棵子树的根节点，这种"分而治之"的思想贯穿所有树形结构的算法。
1.1 二叉树的四种遍历方式
深度优先遍历（DFS）是二叉树算法的基础，包括：
- 前序遍历（根-左-右）：常用于复制树结构
- 中序遍历（左-根-右）：二叉搜索树会得到有序序列
- 后序遍历（左-右-根）：常用于释放树内存
- 层次遍历（BFS）：借助队列实现，常用于求最短路径
cpp复制// 递归前序遍历示例
void preorder(TreeNode* root) {
if(!root) return;
cout << root->val << " "; // 处理当前节点
preorder(root->left); // 递归左子树
preorder(root->right); // 递归右子树
}
在竞赛中，非递归实现往往更高效。以中序遍历为例，使用栈模拟递归过程：
cpp复制vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> st;
while(root || !st.empty()){
while(root){ // 深入左子树
st.push(root);
root = root->left;
}
root = st.top(); // 回溯到父节点
st.pop();
res.push_back(root->val);
root = root->right; // 转向右子树
}
return res;
}
1.2 二叉树的性质与特殊类型
完全二叉树和满二叉树是两类重要的二叉树变体：
- 满二叉树：所有非叶子节点都有两个子节点，且所有叶子在同一层
- 完全二叉树：除最后一层外，其他层节点都达到最大数，且最后一层节点从左向右连续排列
这些性质带来诸多实用特性。例如，完全二叉树可以用数组高效存储，节点i的左子节点为2i+1，右子节点为2i+2。堆结构正是基于这种特性实现的。
二叉搜索树（BST）是另一类重要变体，满足：
- 左子树所有节点值 < 根节点值
- 右子树所有节点值 > 根节点值
- 左右子树也分别为BST
BST的中序遍历会得到有序序列，这使得查找、插入、删除等操作的时间复杂度可以优化到O(h)，h为树高。在理想平衡状态下，h=log₂n，效率极高。
2. 堆结构及其实现原理
第一次实现堆是在解决Top K问题时。当时我惊讶于这种看似简单的结构竟能如此高效地解决复杂问题。堆（Heap）是一种特殊的完全二叉树，满足堆性质：
- 最大堆：每个节点的值都大于或等于其子节点的值
- 最小堆：每个节点的值都小于或等于其子节点的值
堆通常用数组实现，这种表示法既节省空间又便于计算父子关系：
- 父节点i的左子节点：2i+1
- 父节点i的右子节点：2i+2
- 子节点i的父节点：⌊(i-1)/2⌋
2.1 堆的核心操作
堆化（Heapify）是维护堆性质的关键操作，分为向上调整和向下调整两种：
cpp复制// 向下调整（以最大堆为例）
void siftDown(vector<int>& nums, int n, int i) {
while(true) {
int maxPos = i;
int l = 2*i+1, r = 2*i+2;
if(l<n && nums[l]>nums[maxPos]) maxPos = l;
if(r<n && nums[r]>nums[maxPos]) maxPos = r;
if(maxPos == i) break; // 已满足堆性质
swap(nums[i], nums[maxPos]);
i = maxPos;
}
}
建堆过程的时间复杂度不是直觉上的O(nlogn)，而是O(n)。这个结论可以通过数学推导证明：从最后一个非叶子节点开始，自底向上执行向下调整。
2.2 堆的应用场景
堆结构在蓝桥杯竞赛中应用广泛，典型场景包括：
- 优先级队列：Dijkstra算法、Huffman编码等
- Top K问题：维护大小为K的堆
- 中位数维护：使用双堆技巧
- 定时任务调度：按执行时间组织的最小堆
以2020年蓝桥杯省赛真题为例，要求找出数据流的中位数。高效解法就是使用一个大顶堆存储较小半数，一个小顶堆存储较大半数，保持两堆大小平衡：
cpp复制class MedianFinder {
priority_queue<int> max_heap; // 存储较小半数
priority_queue<int, vector<int>, greater<int>> min_heap; // 存储较大半数
public:
void addNum(int num) {
if(max_heap.empty() || num <= max_heap.top()) {
max_heap.push(num);
if(max_heap.size() > min_heap.size()+1) {
min_heap.push(max_heap.top());
max_heap.pop();
}
} else {
min_heap.push(num);
if(min_heap.size() > max_heap.size()) {
max_heap.push(min_heap.top());
min_heap.pop();
}
}
}
double findMedian() {
if(max_heap.size() == min_heap.size())
return (max_heap.top() + min_heap.top()) / 2.0;
return max_heap.top();
}
};
3. STL中的优先队列深度剖析
第一次使用priority_queue是在实现Prim算法时，它极大地简化了我的代码。STL中的priority_queue本质上就是一个堆的实现，默认是最大堆：
cpp复制#include <queue>
priority_queue<int> max_heap; // 默认最大堆
priority_queue<int, vector<int>, greater<int>> min_heap; // 最小堆
3.1 优先队列的底层实现
标准库通常使用vector作为底层容器，通过堆算法维护堆性质。关键操作接口：
- push()：将元素插入末尾，然后向上调整（O(logn)）
- pop()：将堆顶元素与末尾交换，删除末尾，然后向下调整（O(logn)）
- top()：直接返回堆顶元素（O(1)）
自定义比较函数是竞赛中的常见需求。例如，处理结构体时需要重载运算符：
cpp复制struct Node {
int val, x, y;
bool operator<(const Node& rhs) const {
return val > rhs.val; // 最小堆
}
};
priority_queue<Node> pq;
3.2 优先队列的典型应用
在BFS+优先队列解决最短路径问题时，优先队列能确保每次扩展当前最优节点：
cpp复制typedef pair<int, int> PII; // <dist, node>
vector<int> dijkstra(vector<vector<PII>>& graph, int start) {
vector<int> dist(graph.size(), INT_MAX);
priority_queue<PII, vector<PII>, greater<PII>> pq; // 最小堆
dist[start] = 0;
pq.emplace(0, start);
while(!pq.empty()) {
auto [d, u] = pq.top(); pq.pop();
if(d > dist[u]) continue; // 已找到更优解
for(auto& [v, w] : graph[u]) {
if(dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.emplace(dist[v], v);
}
}
}
return dist;
}
在蓝桥杯2019年国赛中有道题目要求找出第K小的素数对，使用优先队列可以避免生成所有可能的组合：
cpp复制vector<int> kthSmallestPrimePair(vector<int>& primes, int k) {
priority_queue<tuple<int,int,int>, vector<tuple<int,int,int>>, greater<>> pq;
for(int i = 0; i < primes.size(); ++i)
pq.emplace(primes[i]+primes[0], i, 0);
while(--k) {
auto [sum, i, j] = pq.top(); pq.pop();
if(j+1 < primes.size())
pq.emplace(primes[i]+primes[j+1], i, j+1);
}
auto [sum, i, j] = pq.top();
return {primes[i], primes[j]};
}
4. 竞赛中的高频题型与解题技巧
在多次蓝桥杯参赛经历中，我发现树和堆相关题目有几个常见套路。掌握这些模式能大幅提升解题效率。
4.1 二叉树题型解题框架
递归三要素是解决二叉树问题的通用框架：
- 终止条件：通常对应空节点或叶子节点
- 本级任务：处理当前节点要完成的工作
- 递归调用：处理左子树和右子树
以"判断二叉树是否对称"为例：
cpp复制bool isSymmetric(TreeNode* root) {
function<bool(TreeNode*, TreeNode*)> check = [&](TreeNode* p, TreeNode* q) {
if(!p && !q) return true; // 终止条件1：都为空
if(!p || !q) return false; // 终止条件2：一个为空
return p->val == q->val // 本级任务：值相等
&& check(p->left, q->right) // 递归调用：镜像比较
&& check(p->right, q->left);
};
return check(root, root);
}
4.2 堆应用的进阶技巧
多路归并是堆的典型应用场景。当需要合并K个有序序列时，堆可以高效维护当前各序列的最小元素：
cpp复制struct ListNode {
int val;
ListNode *next;
bool operator<(const ListNode* rhs) const {
return val > rhs->val; // 最小堆
}
};
ListNode* mergeKLists(vector<ListNode*>& lists) {
priority_queue<ListNode*> pq;
for(auto list : lists)
if(list) pq.push(list);
ListNode dummy, *tail = &dummy;
while(!pq.empty()) {
auto node = pq.top(); pq.pop();
tail->next = node;
tail = tail->next;
if(node->next) pq.push(node->next);
}
return dummy.next;
}
另一个技巧是延迟删除。当需要支持删除任意元素时，可以用额外哈希表记录待删除元素，在堆顶元素匹配时再执行实际删除：
cpp复制class DelayedHeap {
unordered_map<int, int> to_delete;
priority_queue<int> pq;
public:
void push(int x) { pq.push(x); }
void remove(int x) {
if(pq.top() == x) {
pq.pop();
while(!pq.empty() && to_delete[pq.top()]) {
--to_delete[pq.top()];
pq.pop();
}
} else {
++to_delete[x];
}
}
int top() { return pq.top(); }
};
4.3 常见错误与调试技巧
在二叉树递归算法中，最常见的错误是忘记处理空指针情况。一个实用的调试技巧是打印树结构：
cpp复制void printTree(TreeNode* root, int depth = 0) {
if(!root) {
cout << string(depth*4, ' ') << "null\n";
return;
}
cout << string(depth*4, ' ') << root->val << "\n";
printTree(root->left, depth+1);
printTree(root->right, depth+1);
}
对于堆相关问题，边界条件需要特别注意：
- 空堆时的top()/pop()操作
- 元素相等时的比较处理
- 大量数据时的内存管理
在竞赛中遇到堆相关题目时，我通常会先问自己三个问题：
- 堆中应该存储什么信息？（值、索引、还是结构体）
- 比较规则应该如何定义？（最大堆还是最小堆）
- 堆的大小是否需要控制？（如Top K问题）
这种思考方式帮助我在第15届蓝桥杯省赛中快速解决了那道著名的"任务调度"问题，当时有超过60%的参赛者在该题上失分。