Linux 中的红黑树 (rbtree)¶
- 日期:
2007 年 1 月 18 日
- 作者:
Rob Landley <rob@landley.net>
什么是红黑树，它有什么用？¶
红黑树是一种自平衡二叉搜索树，用于存储可排序的键/值数据对。这与基数树（用于高效存储稀疏数组，从而使用长整数索引来插入/访问/删除节点）和哈希表（不保持有序以便按顺序遍历，并且必须针对特定大小和哈希函数进行调优，而红黑树可以优雅地扩展以存储任意键）不同。
红黑树与 AVL 树相似，但在插入和删除方面提供更快的实时有界最坏情况性能（分别最多两次旋转和三次旋转以平衡树），查找时间稍慢（但仍为 O(log n)）。
引用 Linux Weekly News 的话
内核中使用了许多红黑树。deadline 和 CFQ I/O 调度器使用红黑树来跟踪请求；数据包 CD/DVD 驱动程序也这样做。高精度计时器代码使用红黑树来组织未完成的计时器请求。ext3 文件系统在红黑树中跟踪目录条目。虚拟内存区域 (VMAs) 使用红黑树进行跟踪，epoll 文件描述符、加密密钥以及“分层令牌桶”调度器中的网络数据包也是如此。
本文档涵盖 Linux 红黑树实现的用法。有关红黑树的性质和实现的更多信息，请参阅
- Linux Weekly News 关于红黑树的文章
- 维基百科红黑树条目
红黑树的 Linux 实现¶
Linux 的红黑树实现位于“lib/rbtree.c”文件中。要使用它，请“#include <linux/rbtree.h>”。
Linux 红黑树实现经过速度优化，因此比更传统的树实现少了一层间接（并具有更好的缓存局部性）。它不使用指向单独的 `rb_node` 和数据结构的指针，而是将 `struct rb_node` 的每个实例嵌入到它组织的数据结构中。并且不使用比较回调函数指针，而是期望用户编写自己的树搜索和插入函数，这些函数调用提供的红黑树函数。锁定也由红黑树代码的用户负责。
创建新的红黑树¶
红黑树中的数据节点是包含 `struct rb_node` 成员的结构体
struct mytype {
struct rb_node node;
char *keystring;
};
当处理嵌入式 `struct rb_node` 的指针时，可以使用标准 `container_of()` 宏访问包含的数据结构。此外，可以通过 `rb_entry(node, type, member)` 直接访问单个成员。
每个红黑树的根是一个 `rb_root` 结构体，它通过以下方式初始化为空：
struct rb_root mytree = RB_ROOT;
在红黑树中搜索值¶
为你的树编写搜索函数相当简单：从根开始，比较每个值，并根据需要遵循左分支或右分支。
示例
struct mytype *my_search(struct rb_root *root, char *string)
{
struct rb_node *node = root->rb_node;
while (node) {
struct mytype *data = container_of(node, struct mytype, node);
int result;
result = strcmp(string, data->keystring);
if (result < 0)
node = node->rb_left;
else if (result > 0)
node = node->rb_right;
else
return data;
}
return NULL;
}
将数据插入红黑树¶
在树中插入数据首先涉及搜索新节点的插入位置，然后插入节点并重新平衡（“重新着色”）树。
插入搜索与先前的搜索不同，它需要找到要嫁接新节点的指针位置。新节点还需要一个指向其父节点的链接，以用于重新平衡。
示例
int my_insert(struct rb_root *root, struct mytype *data)
{
struct rb_node **new = &(root->rb_node), *parent = NULL;
/* Figure out where to put new node */
while (*new) {
struct mytype *this = container_of(*new, struct mytype, node);
int result = strcmp(data->keystring, this->keystring);
parent = *new;
if (result < 0)
new = &((*new)->rb_left);
else if (result > 0)
new = &((*new)->rb_right);
else
return FALSE;
}
/* Add new node and rebalance tree. */
rb_link_node(&data->node, parent, new);
rb_insert_color(&data->node, root);
return TRUE;
}
在红黑树中删除或替换现有数据¶
要从树中删除现有节点，请调用
void rb_erase(struct rb_node *victim, struct rb_root *tree);
示例
struct mytype *data = mysearch(&mytree, "walrus");
if (data) {
rb_erase(&data->node, &mytree);
myfree(data);
}
要用一个具有相同键的新节点替换树中的现有节点，请调用
void rb_replace_node(struct rb_node *old, struct rb_node *new,
struct rb_root *tree);
以这种方式替换节点不会重新排序树：如果新节点与旧节点没有相同的键，红黑树可能会损坏。
迭代红黑树中存储的元素（按排序顺序）¶
提供了四个函数，用于按排序顺序迭代红黑树的内容。这些函数适用于任意树，不应需要修改或封装（除了锁定目的）
struct rb_node *rb_first(struct rb_root *tree);
struct rb_node *rb_last(struct rb_root *tree);
struct rb_node *rb_next(struct rb_node *node);
struct rb_node *rb_prev(struct rb_node *node);
要开始迭代，调用 `rb_first()` 或 `rb_last()` 并传入树根的指针，这将返回指向树中第一个或最后一个元素中包含的节点结构的指针。要继续，通过在当前节点上调用 `rb_next()` 或 `rb_prev()` 来获取下一个或上一个节点。当没有更多节点时，这将返回 NULL。
迭代器函数返回指向嵌入式 `struct rb_node` 的指针，可以利用 `container_of()` 宏访问其包含的数据结构，并可以通过 `rb_entry(node, type, member)` 直接访问单个成员。
示例
struct rb_node *node;
for (node = rb_first(&mytree); node; node = rb_next(node))
printk("key=%s\n", rb_entry(node, struct mytype, node)->keystring);
缓存红黑树¶
计算最左（最小）节点对于二叉搜索树来说是一项非常常见的任务，例如用于遍历或依赖特定顺序进行自身逻辑的用户。为此，用户可以使用 'struct rb_root_cached' 将 O(logN) 的 `rb_first()` 调用优化为简单的指针获取，避免潜在昂贵的树迭代。这在维护上运行时开销可忽略不计；尽管内存占用较大。
与 `rb_root` 结构类似，缓存的红黑树通过以下方式初始化为空：
struct rb_root_cached mytree = RB_ROOT_CACHED;
缓存红黑树只是一个普通的 `rb_root`，额外有一个指针用于缓存最左节点。这使得 `rb_root_cached` 可以在 `rb_root` 存在的任何地方存在，从而允许支持增强树以及一些额外的接口
struct rb_node *rb_first_cached(struct rb_root_cached *tree);
void rb_insert_color_cached(struct rb_node *, struct rb_root_cached *, bool);
void rb_erase_cached(struct rb_node *node, struct rb_root_cached *);
插入和删除调用都有其各自的增强树对应物
void rb_insert_augmented_cached(struct rb_node *node, struct rb_root_cached *,
bool, struct rb_augment_callbacks *);
void rb_erase_augmented_cached(struct rb_node *, struct rb_root_cached *,
struct rb_augment_callbacks *);
支持增强红黑树¶
增强红黑树是一种红黑树，每个节点中存储了一些附加数据，其中节点 N 的附加数据必须是根植于 N 的子树中所有节点内容的一个函数。这些数据可用于为红黑树增强一些新功能。增强红黑树是在基本红黑树基础设施之上构建的可选功能。需要此功能的红黑树用户在插入和删除节点时，必须调用增强函数并提供用户定义的增强回调。
实现增强红黑树操作的 C 文件必须包含 <linux/rbtree_augmented.h>，而不是 <linux/rbtree.h>。请注意，linux/rbtree_augmented.h 暴露出一些你本不应依赖的红黑树实现细节；请坚持那里文档化的 API，并且也不要从头文件中包含 <linux/rbtree_augmented.h>，以尽量减少你的用户意外依赖这些实现细节的可能性。
在插入时，用户必须更新导致插入节点的路径上的增强信息，然后像往常一样调用 `rb_link_node()` 并调用 `rb_augment_inserted()` 而不是通常的 `rb_insert_color()` 调用。如果 `rb_augment_inserted()` 重新平衡红黑树，它将回调到用户提供的函数中以更新受影响子树上的增强信息。
删除节点时，用户必须调用 `rb_erase_augmented()` 而不是 `rb_erase()`。 `rb_erase_augmented()` 会回调用户提供的函数以更新受影响子树上的增强信息。
在这两种情况下，回调都通过 `struct rb_augment_callbacks` 提供。必须定义 3 个回调：
一个传播回调，它更新给定节点及其祖先的增强值，直到给定的停止点（或 NULL 表示一直更新到根）。
一个复制回调，它将给定子树的增强值复制到新分配的子树根。
一个树旋转回调，它将给定子树的增强值复制到新分配的子树根，并重新计算原子树根的增强信息。
`rb_erase_augmented()` 的编译代码可能会内联传播和复制回调，这导致函数体很大，因此每个增强红黑树用户应只有一个 `rb_erase_augmented()` 调用站点，以限制编译代码大小。
使用示例¶
区间树是增强红黑树的一个例子。参考——Cormen、Leiserson、Rivest 和 Stein 的《算法导论》。有关区间树的更多细节：
经典红黑树只有一个键，不能直接用于存储像 [lo:hi] 这样的区间范围，也无法快速查找与新 lo:hi 的任何重叠或查找新 lo:hi 的精确匹配。
然而，红黑树可以增强以结构化方式存储此类区间范围，从而可以进行高效的查找和精确匹配。
每个节点中存储的“额外信息”是其所有后代节点中的最大 hi (max_hi) 值。此信息只需查看节点及其直接子节点即可在每个节点处维护。这将用于 O(log n) 查找最低匹配（所有可能匹配中最低的起始地址），例如：
struct interval_tree_node *
interval_tree_first_match(struct rb_root *root,
unsigned long start, unsigned long last)
{
struct interval_tree_node *node;
if (!root->rb_node)
return NULL;
node = rb_entry(root->rb_node, struct interval_tree_node, rb);
while (true) {
if (node->rb.rb_left) {
struct interval_tree_node *left =
rb_entry(node->rb.rb_left,
struct interval_tree_node, rb);
if (left->__subtree_last >= start) {
/*
* Some nodes in left subtree satisfy Cond2.
* Iterate to find the leftmost such node N.
* If it also satisfies Cond1, that's the match
* we are looking for. Otherwise, there is no
* matching interval as nodes to the right of N
* can't satisfy Cond1 either.
*/
node = left;
continue;
}
}
if (node->start <= last) { /* Cond1 */
if (node->last >= start) /* Cond2 */
return node; /* node is leftmost match */
if (node->rb.rb_right) {
node = rb_entry(node->rb.rb_right,
struct interval_tree_node, rb);
if (node->__subtree_last >= start)
continue;
}
}
return NULL; /* No match */
}
}
插入/删除是使用以下增强回调定义的：
static inline unsigned long
compute_subtree_last(struct interval_tree_node *node)
{
unsigned long max = node->last, subtree_last;
if (node->rb.rb_left) {
subtree_last = rb_entry(node->rb.rb_left,
struct interval_tree_node, rb)->__subtree_last;
if (max < subtree_last)
max = subtree_last;
}
if (node->rb.rb_right) {
subtree_last = rb_entry(node->rb.rb_right,
struct interval_tree_node, rb)->__subtree_last;
if (max < subtree_last)
max = subtree_last;
}
return max;
}
static void augment_propagate(struct rb_node *rb, struct rb_node *stop)
{
while (rb != stop) {
struct interval_tree_node *node =
rb_entry(rb, struct interval_tree_node, rb);
unsigned long subtree_last = compute_subtree_last(node);
if (node->__subtree_last == subtree_last)
break;
node->__subtree_last = subtree_last;
rb = rb_parent(&node->rb);
}
}
static void augment_copy(struct rb_node *rb_old, struct rb_node *rb_new)
{
struct interval_tree_node *old =
rb_entry(rb_old, struct interval_tree_node, rb);
struct interval_tree_node *new =
rb_entry(rb_new, struct interval_tree_node, rb);
new->__subtree_last = old->__subtree_last;
}
static void augment_rotate(struct rb_node *rb_old, struct rb_node *rb_new)
{
struct interval_tree_node *old =
rb_entry(rb_old, struct interval_tree_node, rb);
struct interval_tree_node *new =
rb_entry(rb_new, struct interval_tree_node, rb);
new->__subtree_last = old->__subtree_last;
old->__subtree_last = compute_subtree_last(old);
}
static const struct rb_augment_callbacks augment_callbacks = {
augment_propagate, augment_copy, augment_rotate
};
void interval_tree_insert(struct interval_tree_node *node,
struct rb_root *root)
{
struct rb_node **link = &root->rb_node, *rb_parent = NULL;
unsigned long start = node->start, last = node->last;
struct interval_tree_node *parent;
while (*link) {
rb_parent = *link;
parent = rb_entry(rb_parent, struct interval_tree_node, rb);
if (parent->__subtree_last < last)
parent->__subtree_last = last;
if (start < parent->start)
link = &parent->rb.rb_left;
else
link = &parent->rb.rb_right;
}
node->__subtree_last = last;
rb_link_node(&node->rb, rb_parent, link);
rb_insert_augmented(&node->rb, root, &augment_callbacks);
}
void interval_tree_remove(struct interval_tree_node *node,
struct rb_root *root)
{
rb_erase_augmented(&node->rb, root, &augment_callbacks);
}