1. Splay树概述与核心思想
Splay树（伸展树）是一种自平衡二叉搜索树，由计算机科学家Daniel Sleator和Robert Tarjan于1985年提出。与AVL树和红黑树不同，Splay树不通过严格的平衡条件来保证性能，而是采用一种称为"伸展"（splaying）的启发式策略，将最近访问的节点移动到根节点位置。
1.1 基本特性
Splay树的核心特性在于它的自适应能力。每次对树进行操作（查找、插入或删除）后，都会通过一系列旋转将相关节点移动到根节点位置。这种策略基于计算机科学中著名的"局部性原理"——最近被访问的数据很可能在不久的将来再次被访问。
从实现角度看，Splay树具有以下特点：
- 不需要存储额外的平衡信息（如AVL树中的平衡因子）
- 基本操作的平均时间复杂度为O(log n)
- 实现相对简单，核心逻辑集中在伸展操作上
- 特别适合访问模式具有局部性的场景
1.2 核心操作原理
Splay树的核心操作是"splay"，即伸展操作。这个操作会将特定节点通过旋转移动到根节点位置，同时在这个过程中对树的结构进行调整，使得后续对相同或附近节点的访问更加高效。
伸展操作通过三种基本旋转组合实现：
- Zig旋转：当目标节点是根节点的直接子节点时使用
- Zig-Zig旋转：当目标节点和父节点都是左孩子或都是右孩子时使用
- Zig-Zag旋转：当目标节点和父节点的相对位置不同时使用
这些旋转不仅移动目标节点到根位置，还会在过程中自动平衡树的结构。虽然单次操作可能耗时较长，但从均摊分析的角度看，一系列操作的平均时间复杂度仍然是O(log n)。
2. Splay树的实现细节
2.1 节点结构设计
Splay树的节点结构比普通二叉搜索树更为丰富，因为它需要支持伸展操作和额外的功能。以下是典型的节点结构：
cpp复制struct Node {
int key; // 节点存储的键值
int cnt; // 相同键值的计数（处理重复元素）
int size; // 子树大小（用于排名查询）
Node *left; // 左子节点指针
Node *right; // 右子节点指针
Node *parent; // 父节点指针（伸展操作必需）
// 构造函数
Node(int val) : key(val), cnt(1), size(1),
left(nullptr), right(nullptr),
parent(nullptr) {}
};
关键设计考虑：
- parent指针：这是实现伸展操作的关键，因为旋转需要知道节点的父节点
- size字段：用于支持排名和选择操作，存储子树的大小（包括所有重复元素）
- cnt字段：处理重复元素，避免为相同值创建多个节点
2.2 旋转操作实现
旋转是Splay树的基础操作，分为左旋和右旋两种。旋转的核心是保持二叉搜索树性质的同时改变树的结构。
cpp复制void rotate(Node *x) {
Node *p = x->parent; // 父节点
Node *g = p->parent; // 祖父节点
if (x == p->left) { // x是左孩子，执行右旋
p->left = x->right;
if (x->right) x->right->parent = p;
x->right = p;
} else { // x是右孩子，执行左旋
p->right = x->left;
if (x->left) x->left->parent = p;
x->left = p;
}
p->parent = x;
x->parent = g;
if (g) {
if (g->left == p) g->left = x;
else g->right = x;
} else {
root = x; // x成为新根
}
update(p); // 更新父节点的size
update(x); // 更新当前节点的size
}
旋转后必须更新受影响节点的size信息，这是支持排名操作的关键。
2.3 伸展操作实现
伸展操作是Splay树的核心，它通过一系列旋转将目标节点移动到根位置。伸展操作需要考虑三种不同的情况：
cpp复制void splay(Node *x, Node *target = nullptr) {
while (x->parent != target) {
Node *p = x->parent;
Node *g = p->parent;
if (g != target) {
// 双旋情况
if ((x == p->left) == (p == g->left)) {
// Zig-Zig情况
rotate(p);
} else {
// Zig-Zag情况
rotate(x);
}
}
rotate(x); // 最后执行单旋
}
if (target == nullptr) root = x;
}
伸展操作的选择策略：
- 如果父节点是目标节点，直接执行单旋（Zig）
- 如果存在祖父节点且不在目标位置，根据节点排列选择Zig-Zig或Zig-Zag
- 最后总是执行一次单旋确保节点到达目标位置
3. 基本操作实现
3.1 查找操作
查找操作不仅需要找到目标节点，还要将其伸展到根位置：
cpp复制Node* find(int val) {
Node *cur = root;
Node *prev = nullptr;
while (cur) {
prev = cur;
if (val == cur->key) break;
else if (val < cur->key) cur = cur->left;
else cur = cur->right;
}
if (prev) splay(prev); // 伸展最后访问的节点
return (prev && prev->key == val) ? prev : nullptr;
}
查找操作的特点：
- 无论是否找到目标值，都会将最后访问的节点伸展到根
- 这使得后续对相同或附近值的访问更加高效
- 平均时间复杂度为O(log n)
3.2 插入操作
插入操作需要处理重复元素的情况，并将新节点伸展到根：
cpp复制void insert(int val) {
if (!root) {
root = new Node(val);
return;
}
Node *cur = root;
while (true) {
if (val == cur->key) {
cur->cnt++; // 处理重复元素
break;
} else if (val < cur->key) {
if (!cur->left) {
cur->left = new Node(val);
cur->left->parent = cur;
cur = cur->left;
break;
}
cur = cur->left;
} else {
if (!cur->right) {
cur->right = new Node(val);
cur->right->parent = cur;
cur = cur->right;
break;
}
cur = cur->right;
}
}
splay(cur); // 将新节点伸展到根
update(root); // 更新根节点的size信息
}
插入操作的注意事项：
- 重复元素通过增加计数处理，而不是创建新节点
- 新插入的节点会被立即伸展到根位置
- 需要更新路径上所有节点的size信息
3.3 删除操作
删除操作是最复杂的操作之一，需要处理多种情况：
cpp复制bool remove(int val) {
Node *x = find(val); // 查找并伸展节点到根
if (!x || x->key != val) return false;
if (x->cnt > 1) {
x->cnt--; // 减少重复计数
update(x);
return true;
}
// 实际删除节点
Node *leftSub = x->left;
Node *rightSub = x->right;
if (leftSub) leftSub->parent = nullptr;
if (rightSub) rightSub->parent = nullptr;
delete x;
if (!leftSub) {
root = rightSub;
} else if (!rightSub) {
root = leftSub;
} else {
// 合并左右子树
root = leftSub;
Node *maxLeft = leftSub;
while (maxLeft->right) maxLeft = maxLeft->right;
splay(maxLeft); // 将左子树最大值伸展到根
root->right = rightSub;
rightSub->parent = root;
update(root);
}
return true;
}
删除操作的关键点：
- 首先查找并伸展目标节点到根
- 处理重复元素情况（减少计数）
- 实际删除节点时需要合并左右子树
- 合并策略：将左子树的最大值伸展到根，然后连接右子树
4. 扩展功能实现
4.1 排名查询
排名查询是许多应用场景（如排行榜）需要的功能：
cpp复制int getRank(int val) {
Node *x = find(val);
if (!x) return -1; // 值不存在
// 排名 = 左子树大小 + 1
return (x->left ? x->left->size : 0) + 1;
}
排名查询的实现要点：
- 首先执行查找操作，将目标节点伸展到根
- 排名等于左子树的大小加1（因为左子树所有节点都小于当前节点）
- 时间复杂度为O(log n)，主要由查找操作决定
4.2 选择操作（查找第k小元素）
选择操作是排名查询的逆操作：
cpp复制int select(int k) {
Node *cur = root;
while (cur) {
int leftSize = cur->left ? cur->left->size : 0;
if (k <= leftSize) {
cur = cur->left;
} else if (k > leftSize + cur->cnt) {
k -= leftSize + cur->cnt;
cur = cur->right;
} else {
splay(cur); // 将找到的节点伸展到根
return cur->key;
}
}
return -1; // 无效的k
}
选择操作的实现策略：
- 比较左子树大小与k的关系
- 如果k在左子树范围内，递归查找左子树
- 如果k在当前节点范围内，返回当前节点
- 否则递归查找右子树，并调整k值
- 最后将找到的节点伸展到根
4.3 前驱和后继查询
前驱和后继查询可以通过伸展树特性高效实现：
cpp复制int predecessor(int val) {
insert(val); // 临时插入目标值
Node *x = root->left;
while (x && x->right) x = x->right; // 找左子树最大值
int pred = x ? x->key : -INF;
remove(val); // 删除临时插入的值
return pred;
}
int successor(int val) {
insert(val); // 临时插入目标值
Node *x = root->right;
while (x && x->left) x = x->left; // 找右子树最小值
int succ = x ? x->key : INF;
remove(val); // 删除临时插入的值
return succ;
}
这种实现方式的优点：
- 代码简洁，不需要处理复杂的边界条件
- 利用伸展树特性，自动将相关节点移动到根位置
- 时间复杂度仍然是O(log n)，因为插入和删除都是O(log n)操作
5. 性能分析与优化
5.1 时间复杂度分析
Splay树的性能分析基于均摊分析（Amortized Analysis）而非最坏情况分析：
- 单次操作：最坏情况下可能达到O(n)
- m次操作序列：总时间复杂度为O(m log n)，因此均摊每次操作O(log n)
- 访问模式敏感：对于具有局部性的访问模式，实际性能往往优于理论值
Splay树的性能优势体现在：
- 不需要维护严格的平衡条件，减少了平衡操作的开销
- 自适应特性使得热点数据的访问更加高效
- 实现相对简单，常数因子较小
5.2 哨兵节点的使用
在实际实现中，使用哨兵节点可以简化边界条件处理：
cpp复制SplayTree() : root(nullptr) {
insert(-INF); // 左哨兵（最小值）
insert(INF); // 右哨兵（最大值）
}
哨兵节点的作用：
- 确保树永远非空，避免空指针检查
- 简化前驱/后继查询的边界条件处理
- 在排名查询中，左哨兵的排名为0，可以作为基准
5.3 内存管理与优化
Splay树需要注意内存管理问题：
- 析构函数：需要递归释放所有节点内存
cpp复制~SplayTree() { destroy(root); }
void destroy(Node *x) {
if (!x) return;
destroy(x->left);
destroy(x->right);
delete x;
}
- 重复元素处理：通过计数而非创建多个节点节省内存
- 节点池技术：对于频繁插入删除的场景，可以使用对象池重用节点
6. 应用场景与比较
6.1 适用场景
Splay树特别适合以下场景：
- 缓存系统：热点数据会自动移动到根位置，访问更快
- 垃圾收集算法：如"自调整"的垃圾收集器
- 网络路由表：频繁访问的路由项会被缓存到顶部
- 数据压缩：如自适应哈夫曼编码
- 实现有序集合：支持快速插入、删除和查询操作
6.2 与其他平衡树的比较
| 特性 | Splay树 | AVL树 | 红黑树 | 普通BST |
|---|---|---|---|---|
| 平衡保证 | 无 | 严格 | 宽松 | 无 |
| 最坏时间复杂度 | O(n) | O(log n) | O(log n) | O(n) |
| 平均时间复杂度 | O(log n) | O(log n) | O(log n) | O(log n) |
| 实现复杂度 | 简单 | 中等 | 复杂 | 简单 |
| 额外存储开销 | 父指针 | 平衡因子 | 颜色位 | 无 |
| 自适应特性 | 强 | 无 | 无 | 无 |
6.3 使用建议
-
适合场景：
- 访问模式具有局部性
- 不需要严格的最坏情况保证
- 实现简单性比绝对性能更重要
-
不适合场景：
- 需要保证每次操作严格O(log n)时间
- 实时系统或硬实时约束
- 访问模式完全随机且无局部性
-
实现建议：
- 总是使用父指针简化旋转操作
- 添加size字段支持排名查询
- 使用哨兵节点简化边界条件处理
- 考虑内存管理，特别是频繁插入删除的场景
7. 实战案例：洛谷P3369实现
7.1 题目要求分析
洛谷P3369要求实现一个支持以下操作的有序集合：
- 插入数值x
- 删除数值x（若有多个相同x，只删除一个）
- 查询数值x的排名
- 查询排名为k的数值
- 查询x的前驱（小于x的最大数）
- 查询x的后继（大于x的最小数）
7.2 完整实现代码
cpp复制#include <iostream>
#include <algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
struct Node {
int key, cnt, size;
Node *left, *right, *parent;
Node(int val) : key(val), cnt(1), size(1),
left(nullptr), right(nullptr),
parent(nullptr) {}
};
class SplayTree {
private:
Node *root;
void update(Node *x) {
if (x) {
x->size = x->cnt;
if (x->left) x->size += x->left->size;
if (x->right) x->size += x->right->size;
}
}
bool isLeftChild(Node *x) {
return x == x->parent->left;
}
void rotate(Node *x) {
Node *p = x->parent;
Node *g = p->parent;
if (isLeftChild(x)) {
p->left = x->right;
if (x->right) x->right->parent = p;
x->right = p;
} else {
p->right = x->left;
if (x->left) x->left->parent = p;
x->left = p;
}
p->parent = x;
x->parent = g;
if (g) {
if (g->left == p) g->left = x;
else g->right = x;
} else {
root = x;
}
update(p);
update(x);
}
void splay(Node *x, Node *target = nullptr) {
while (x->parent != target) {
Node *p = x->parent;
Node *g = p->parent;
if (g != target) {
if (isLeftChild(x) == isLeftChild(p)) rotate(p);
else rotate(x);
}
rotate(x);
}
if (target == nullptr) root = x;
}
Node* findNode(int val) {
Node *cur = root;
while (cur) {
if (cur->key == val) break;
else if (val < cur->key) {
if (!cur->left) break;
cur = cur->left;
} else {
if (!cur->right) break;
cur = cur->right;
}
}
if (cur) splay(cur);
return cur;
}
void destroy(Node *x) {
if (!x) return;
destroy(x->left);
destroy(x->right);
delete x;
}
public:
SplayTree() : root(nullptr) {
insert(-INF);
insert(INF);
}
~SplayTree() { destroy(root); }
void insert(int val) {
if (!root) {
root = new Node(val);
update(root);
return;
}
Node *cur = root;
Node *p = nullptr;
while (cur) {
p = cur;
if (cur->key == val) {
cur->cnt++;
update(cur);
splay(cur);
return;
} else if (val < cur->key) {
cur = cur->left;
} else {
cur = cur->right;
}
}
Node *newNode = new Node(val);
newNode->parent = p;
if (val < p->key) p->left = newNode;
else p->right = newNode;
update(p);
splay(newNode);
}
bool remove(int val) {
Node *x = findNode(val);
if (!x || x->key != val) return false;
if (x->cnt > 1) {
x->cnt--;
update(x);
return true;
}
splay(x);
Node *leftSub = x->left;
Node *rightSub = x->right;
delete x;
root = nullptr;
if (leftSub) {
leftSub->parent = nullptr;
root = leftSub;
Node *maxLeft = leftSub;
while (maxLeft->right) maxLeft = maxLeft->right;
splay(maxLeft);
root->right = rightSub;
if (rightSub) rightSub->parent = root;
update(root);
} else if (rightSub) {
rightSub->parent = nullptr;
root = rightSub;
}
return true;
}
int getRank(int val) {
Node *x = findNode(val);
if (x->key < val) splay(x);
return root->left->size;
}
int getKth(int k) {
k++;
Node *cur = root;
while (cur) {
int leftSize = cur->left ? cur->left->size : 0;
if (leftSize >= k) {
cur = cur->left;
} else if (leftSize + cur->cnt < k) {
k -= leftSize + cur->cnt;
cur = cur->right;
} else {
splay(cur);
return cur->key;
}
}
return -1;
}
int getPrev(int val) {
insert(val);
Node *x = root->left;
while (x->right) x = x->right;
int res = x->key;
remove(val);
return res;
}
int getNext(int val) {
insert(val);
Node *x = root->right;
while (x->left) x = x->left;
int res = x->key;
remove(val);
return res;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
SplayTree st;
while (n--) {
int op, x;
cin >> op >> x;
switch (op) {
case 1: st.insert(x); break;
case 2: st.remove(x); break;
case 3: cout << st.getRank(x) << endl; break;
case 4: cout << st.getKth(x) << endl; break;
case 5: cout << st.getPrev(x) << endl; break;
case 6: cout << st.getNext(x) << endl; break;
}
}
return 0;
}
7.3 代码解析与优化点
- 输入输出优化：
cpp复制ios::sync_with_stdio(false);
cin.tie(nullptr);
这对大规模数据输入至关重要，可以显著提高IO速度。
-
哨兵节点处理：
构造函数中自动插入-INF和INF作为哨兵，简化了边界条件处理。 -
排名查询优化：
cpp复制return root->left->size;
利用伸展树特性，查询排名只需返回左子树大小。
-
前驱/后继查询技巧：
通过临时插入目标值并立即删除，简化了实现逻辑。 -
内存管理：
析构函数递归销毁所有节点，避免内存泄漏。
8. 常见问题与调试技巧
8.1 常见错误
-
旋转操作错误：
- 忘记更新父指针
- 旋转后没有正确更新子树大小
- 没有处理祖父节点的连接
-
伸展操作错误：
- 没有正确处理Zig-Zig和Zig-Zag情况
- 伸展后没有正确设置根节点
- 目标位置设置错误
-
内存问题：
- 忘记释放删除的节点
- 重复释放同一节点
- 内存泄漏
-
边界条件：
- 空树处理不当
- 最小/最大值查询错误
- 重复元素计数错误
8.2 调试技巧
-
可视化工具：
- 实现树的打印功能，便于观察结构
cpp复制void printTree(Node *node, int depth = 0) { if (!node) return; printTree(node->right, depth + 1); cout << string(depth * 4, ' ') << node->key << "(" << node->size << ")" << endl; printTree(node->left, depth + 1); } -
断言检查：
- 在关键操作后添加断言检查不变式
cpp复制assert(node->size == node->cnt + (node->left ? node->left->size : 0) + (node->right ? node->right->size : 0)); -
小规模测试：
- 从简单案例开始测试（如插入1-5顺序和逆序）
- 验证每种旋转情况（Zig, Zig-Zig, Zig-Zag）
-
性能分析：
- 对大规模随机操作进行时间测试
- 检查是否符合O(log n)的均摊复杂度
8.3 性能优化建议
-
节点池技术：
对于频繁插入删除的场景，可以预分配节点池重用内存。 -
非递归实现：
将递归操作改为迭代实现，减少函数调用开销。 -
批量操作优化：
对于批量插入/删除，可以优化伸展策略。 -
内存布局优化：
使用内存紧凑的数据结构减少缓存未命中。
9. 扩展与变种
9.1 区间操作的Splay树
Splay树可以扩展支持区间操作，如区间翻转、区间求和等。核心思想是将区间通过伸展操作聚集到同一子树中。
cpp复制void reverseInterval(int l, int r) {
Node *left = findKth(l - 1); // 将第l-1个节点伸展到根
Node *right = findKth(r + 1); // 将第r+1个节点伸展到右子树
Node *subtree = right->left; // 现在subtree就是区间[l,r]
subtree->reverseFlag ^= 1; // 标记翻转
}
9.2 持久化Splay树
通过路径复制技术可以实现持久化Splay树，支持版本回溯：
cpp复制Node* persistentInsert(Node *root, int val) {
if (!root) return new Node(val);
Node *newRoot = new Node(*root); // 复制当前节点
if (val < root->key) {
newRoot->left = persistentInsert(root->left, val);
newRoot->left->parent = newRoot;
} else {
newRoot->right = persistentInsert(root->right, val);
newRoot->right->parent = newRoot;
}
update(newRoot);
return splay(newRoot); // 持久化伸展
}
9.3 并行Splay树
通过锁或事务内存等技术，可以实现并行化的Splay树，提高多核环境下的性能。
10. 总结与经验分享
Splay树是一种非常有趣且实用的数据结构，它的自适应性使其在许多实际场景中表现优异。通过本实现，我们可以总结以下几点经验：
-
父指针是关键：没有父指针就无法实现高效的伸展操作，这是Splay树实现中最容易出错的部分。
-
均摊分析很重要：不要被单次操作的最坏情况吓到，实际应用中均摊性能往往很好。
-
局部性是朋友：Splay树在访问模式具有局部性时表现最佳，这是设计算法时要考虑的。
-
简洁胜过复杂：相比AVL和红黑树，Splay树的实现更为简洁，适合教学和快速原型开发。
-
调试需要耐心：旋转和伸展操作容易出错，需要仔细设计和充分测试。
在实际项目中是否选择Splay树，需要权衡以下因素：
- 是否需要严格的最坏情况保证
- 访问模式是否具有局部性
- 实现复杂度和维护成本
- 内存和性能的特定要求
对于大多数需要有序集合且访问模式具有局部性的场景，Splay树都是一个值得考虑的优秀选择。它的自适应特性和相对简单的实现，使其成为算法工具箱中一件有力的武器。