Documentation/translations/zh_CN/core-api/rbtree.rst

   1 .. SPDX-License-Identifier: GPL-2.0
   2 .. include:: ../disclaimer-zh_CN.rst
   3
   4 :Original: Documentation/core-api/rbtree.rst
   5
   6 :翻译:
   7
   8   唐艺舟 Tang Yizhou <tangyeechou@gmail.com>
   9
  10 =========================
  11 Linux中的红黑树（rbtree）
  12 =========================
  13
  14
  15 :日期: 2007年1月18日
  16 :作者: Rob Landley <rob@landley.net>
  17
  18 何为红黑树，它们有什么用？
  19 --------------------------
  20
  21 红黑树是一种自平衡二叉搜索树，被用来存储可排序的键/值数据对。这与基数树（被用来高效
  22 存储稀疏数组，因此使用长整型下标来插入/访问/删除结点）和哈希表（没有保持排序因而无法
  23 容易地按序遍历，同时必须调节其大小和哈希函数，然而红黑树可以优雅地伸缩以便存储任意
  24 数量的键）不同。
  25
  26 红黑树和AVL树类似，但在插入和删除时提供了更快的实时有界的最坏情况性能（分别最多两次
  27 旋转和三次旋转，来平衡树），查询时间轻微变慢（但时间复杂度仍然是O(log n)）。
  28
  29 引用Linux每周新闻（Linux Weekly News）：
  30
  31     内核中有多处红黑树的使用案例。最后期限调度器和完全公平排队（CFQ）I/O调度器利用
  32     红黑树跟踪请求；数据包CD/DVD驱动程序也是如此。高精度时钟代码使用一颗红黑树组织
  33     未完成的定时器请求。ext3文件系统用红黑树跟踪目录项。虚拟内存区域（VMAs）、epoll
  34     文件描述符、密码学密钥和在“分层令牌桶”调度器中的网络数据包都由红黑树跟踪。
  35
  36 本文档涵盖了对Linux红黑树实现的使用方法。更多关于红黑树的性质和实现的信息，参见：
  37
  38   Linux每周新闻关于红黑树的文章
  39     https://lwn.net/Articles/184495/
  40
  41   维基百科红黑树词条
  42     https://en.wikipedia.org/wiki/Red-black_tree
  43
  44 红黑树的Linux实现
  45 -----------------
  46
  47 Linux的红黑树实现在文件“lib/rbtree.c”中。要使用它，需要“#include <linux/rbtree.h>”。
  48
  49 Linux的红黑树实现对速度进行了优化，因此比传统的实现少一个间接层（有更好的缓存局部性）。
  50 每个rb_node结构体的实例嵌入在它管理的数据结构中，因此不需要靠指针来分离rb_node和它
  51 管理的数据结构。用户应该编写他们自己的树搜索和插入函数，来调用已提供的红黑树函数，
  52 而不是使用一个比较回调函数指针。加锁代码也留给红黑树的用户编写。
  53
  54 创建一颗红黑树
  55 --------------
  56
  57 红黑树中的数据结点是包含rb_node结构体成员的结构体::
  58
  59   struct mytype {
  60         struct rb_node node;
  61         char *keystring;
  62   };
  63
  64 当处理一个指向内嵌rb_node结构体的指针时，包住rb_node的结构体可用标准的container_of()
  65 宏访问。此外，个体成员可直接用rb_entry(node, type, member)访问。
  66
  67 每颗红黑树的根是一个rb_root数据结构，它由以下方式初始化为空:
  68
  69   struct rb_root mytree = RB_ROOT;
  70
  71 在一颗红黑树中搜索值
  72 --------------------
  73
  74 为你的树写一个搜索函数是相当简单的：从树根开始，比较每个值，然后根据需要继续前往左边或
  75 右边的分支。
  76
  77 示例::
  78
  79   struct mytype *my_search(struct rb_root *root, char *string)
  80   {
  81         struct rb_node *node = root->rb_node;
  82
  83         while (node) {
  84                 struct mytype *data = container_of(node, struct mytype, node);
  85                 int result;
  86
  87                 result = strcmp(string, data->keystring);
  88
  89                 if (result < 0)
  90                         node = node->rb_left;
  91                 else if (result > 0)
  92                         node = node->rb_right;
  93                 else
  94                         return data;
  95         }
  96         return NULL;
  97   }
  98
  99 在一颗红黑树中插入数据
 100 ----------------------
 101
 102 在树中插入数据的步骤包括：首先搜索插入新结点的位置，然后插入结点并对树再平衡
 103 （"recoloring"）。
 104
 105 插入的搜索和上文的搜索不同，它要找到嫁接新结点的位置。新结点也需要一个指向它的父节点
 106 的链接，以达到再平衡的目的。
 107
 108 示例::
 109
 110   int my_insert(struct rb_root *root, struct mytype *data)
 111   {
 112         struct rb_node **new = &(root->rb_node), *parent = NULL;
 113
 114         /* Figure out where to put new node */
 115         while (*new) {
 116                 struct mytype *this = container_of(*new, struct mytype, node);
 117                 int result = strcmp(data->keystring, this->keystring);
 118
 119                 parent = *new;
 120                 if (result < 0)
 121                         new = &((*new)->rb_left);
 122                 else if (result > 0)
 123                         new = &((*new)->rb_right);
 124                 else
 125                         return FALSE;
 126         }
 127
 128         /* Add new node and rebalance tree. */
 129         rb_link_node(&data->node, parent, new);
 130         rb_insert_color(&data->node, root);
 131
 132         return TRUE;
 133   }
 134
 135 在一颗红黑树中删除或替换已经存在的数据
 136 --------------------------------------
 137
 138 若要从树中删除一个已经存在的结点，调用::
 139
 140   void rb_erase(struct rb_node *victim, struct rb_root *tree);
 141
 142 示例::
 143
 144   struct mytype *data = mysearch(&mytree, "walrus");
 145
 146   if (data) {
 147         rb_erase(&data->node, &mytree);
 148         myfree(data);
 149   }
 150
 151 若要用一个新结点替换树中一个已经存在的键值相同的结点，调用::
 152
 153   void rb_replace_node(struct rb_node *old, struct rb_node *new,
 154                         struct rb_root *tree);
 155
 156 通过这种方式替换结点不会对树做重排序：如果新结点的键值和旧结点不同，红黑树可能被
 157 破坏。
 158
 159 （按排序的顺序）遍历存储在红黑树中的元素
 160 ----------------------------------------
 161
 162 我们提供了四个函数，用于以排序的方式遍历一颗红黑树的内容。这些函数可以在任意红黑树
 163 上工作，并且不需要被修改或包装（除非加锁的目的）::
 164
 165   struct rb_node *rb_first(struct rb_root *tree);
 166   struct rb_node *rb_last(struct rb_root *tree);
 167   struct rb_node *rb_next(struct rb_node *node);
 168   struct rb_node *rb_prev(struct rb_node *node);
 169
 170 要开始迭代，需要使用一个指向树根的指针调用rb_first()或rb_last()，它将返回一个指向
 171 树中第一个或最后一个元素所包含的节点结构的指针。要继续的话，可以在当前结点上调用
 172 rb_next()或rb_prev()来获取下一个或上一个结点。当没有剩余的结点时，将返回NULL。
 173
 174 迭代器函数返回一个指向被嵌入的rb_node结构体的指针，由此，包住rb_node的结构体可用
 175 标准的container_of()宏访问。此外，个体成员可直接用rb_entry(node, type, member)
 176 访问。
 177
 178 示例::
 179
 180   struct rb_node *node;
 181   for (node = rb_first(&mytree); node; node = rb_next(node))
 182         printk("key=%s\n", rb_entry(node, struct mytype, node)->keystring);
 183
 184 带缓存的红黑树
 185 --------------
 186
 187 计算最左边（最小的）结点是二叉搜索树的一个相当常见的任务，例如用于遍历，或用户根据
 188 他们自己的逻辑依赖一个特定的顺序。为此，用户可以使用'struct rb_root_cached'来优化
 189 时间复杂度为O(logN)的rb_first()的调用，以简单地获取指针，避免了潜在的昂贵的树迭代。
 190 维护操作的额外运行时间开销可忽略，不过内存占用较大。
 191
 192 和rb_root结构体类似，带缓存的红黑树由以下方式初始化为空::
 193
 194   struct rb_root_cached mytree = RB_ROOT_CACHED;
 195
 196 带缓存的红黑树只是一个常规的rb_root，加上一个额外的指针来缓存最左边的节点。这使得
 197 rb_root_cached可以存在于rb_root存在的任何地方，并且只需增加几个接口来支持带缓存的
 198 树::
 199
 200   struct rb_node *rb_first_cached(struct rb_root_cached *tree);
 201   void rb_insert_color_cached(struct rb_node *, struct rb_root_cached *, bool);
 202   void rb_erase_cached(struct rb_node *node, struct rb_root_cached *);
 203
 204 操作和删除也有对应的带缓存的树的调用::
 205
 206   void rb_insert_augmented_cached(struct rb_node *node, struct rb_root_cached *,
 207                                   bool, struct rb_augment_callbacks *);
 208   void rb_erase_augmented_cached(struct rb_node *, struct rb_root_cached *,
 209                                  struct rb_augment_callbacks *);
 210
 211
 212 对增强型红黑树的支持
 213 --------------------
 214
 215 增强型红黑树是一种在每个结点里存储了“一些”附加数据的红黑树，其中结点N的附加数据
 216 必须是以N为根的子树中所有结点的内容的函数。它是建立在红黑树基础设施之上的可选特性。
 217 想要使用这个特性的红黑树用户，插入和删除结点时必须调用增强型接口并提供增强型回调函数。
 218
 219 实现增强型红黑树操作的C文件必须包含<linux/rbtree_augmented.h>而不是<linux/rbtree.h>。
 220 注意，linux/rbtree_augmented.h暴露了一些红黑树实现的细节而你不应依赖它们，请坚持
 221 使用文档记录的API，并且不要在头文件中包含<linux/rbtree_augmented.h>，以最小化你的
 222 用户意外地依赖这些实现细节的可能。
 223
 224 插入时，用户必须更新通往被插入节点的路径上的增强信息，然后像往常一样调用rb_link_node()，
 225 然后是rb_augment_inserted()而不是平时的rb_insert_color()调用。如果
 226 rb_augment_inserted()再平衡了红黑树，它将回调至一个用户提供的函数来更新受影响的
 227 子树上的增强信息。
 228
 229 删除一个结点时，用户必须调用rb_erase_augmented()而不是rb_erase()。
 230 rb_erase_augmented()回调至一个用户提供的函数来更新受影响的子树上的增强信息。
 231
 232 在两种情况下，回调都是通过rb_augment_callbacks结构体提供的。必须定义3个回调：
 233
 234 - 一个传播回调，它更新一个给定结点和它的祖先们的增强数据，直到一个给定的停止点
 235   （如果是NULL，将更新一路更新到树根）。
 236
 237 - 一个复制回调，它将一颗给定子树的增强数据复制到一个新指定的子树树根。
 238
 239 - 一个树旋转回调，它将一颗给定的子树的增强值复制到新指定的子树树根上，并重新计算
 240   先前的子树树根的增强值。
 241
 242 rb_erase_augmented()编译后的代码可能会内联传播、复制回调，这将导致函数体积更大，
 243 因此每个增强型红黑树的用户应该只有一个rb_erase_augmented()的调用点，以限制编译后
 244 的代码大小。
 245
 246
 247 使用示例
 248 ^^^^^^^^
 249
 250 区间树是增强型红黑树的一个例子。参考Cormen，Leiserson，Rivest和Stein写的
 251 《算法导论》。区间树的更多细节：
 252
 253 经典的红黑树只有一个键，它不能直接用来存储像[lo:hi]这样的区间范围，也不能快速查找
 254 与新的lo:hi重叠的部分，或者查找是否有与新的lo:hi完全匹配的部分。
 255
 256 然而，红黑树可以被增强，以一种结构化的方式来存储这种区间范围，从而使高效的查找和
 257 精确匹配成为可能。
 258
 259 这个存储在每个节点中的“额外信息”是其所有后代结点中的最大hi（max_hi）值。这个信息
 260 可以保持在每个结点上，只需查看一下该结点和它的直系子结点们。这将被用于时间复杂度
 261 为O(log n)的最低匹配查找（所有可能的匹配中最低的起始地址），就像这样::
 262
 263   struct interval_tree_node *
 264   interval_tree_first_match(struct rb_root *root,
 265                             unsigned long start, unsigned long last)
 266   {
 267         struct interval_tree_node *node;
 268
 269         if (!root->rb_node)
 270                 return NULL;
 271         node = rb_entry(root->rb_node, struct interval_tree_node, rb);
 272
 273         while (true) {
 274                 if (node->rb.rb_left) {
 275                         struct interval_tree_node *left =
 276                                 rb_entry(node->rb.rb_left,
 277                                          struct interval_tree_node, rb);
 278                         if (left->__subtree_last >= start) {
 279                                 /*
 280                                  * Some nodes in left subtree satisfy Cond2.
 281                                  * Iterate to find the leftmost such node N.
 282                                  * If it also satisfies Cond1, that's the match
 283                                  * we are looking for. Otherwise, there is no
 284                                  * matching interval as nodes to the right of N
 285                                  * can't satisfy Cond1 either.
 286                                  */
 287                                 node = left;
 288                                 continue;
 289                         }
 290                 }
 291                 if (node->start <= last) {              /* Cond1 */
 292                         if (node->last >= start)        /* Cond2 */
 293                                 return node;    /* node is leftmost match */
 294                         if (node->rb.rb_right) {
 295                                 node = rb_entry(node->rb.rb_right,
 296                                         struct interval_tree_node, rb);
 297                                 if (node->__subtree_last >= start)
 298                                         continue;
 299                         }
 300                 }
 301                 return NULL;    /* No match */
 302         }
 303   }
 304
 305 插入/删除是通过以下增强型回调来定义的::
 306
 307   static inline unsigned long
 308   compute_subtree_last(struct interval_tree_node *node)
 309   {
 310         unsigned long max = node->last, subtree_last;
 311         if (node->rb.rb_left) {
 312                 subtree_last = rb_entry(node->rb.rb_left,
 313                         struct interval_tree_node, rb)->__subtree_last;
 314                 if (max < subtree_last)
 315                         max = subtree_last;
 316         }
 317         if (node->rb.rb_right) {
 318                 subtree_last = rb_entry(node->rb.rb_right,
 319                         struct interval_tree_node, rb)->__subtree_last;
 320                 if (max < subtree_last)
 321                         max = subtree_last;
 322         }
 323         return max;
 324   }
 325
 326   static void augment_propagate(struct rb_node *rb, struct rb_node *stop)
 327   {
 328         while (rb != stop) {
 329                 struct interval_tree_node *node =
 330                         rb_entry(rb, struct interval_tree_node, rb);
 331                 unsigned long subtree_last = compute_subtree_last(node);
 332                 if (node->__subtree_last == subtree_last)
 333                         break;
 334                 node->__subtree_last = subtree_last;
 335                 rb = rb_parent(&node->rb);
 336         }
 337   }
 338
 339   static void augment_copy(struct rb_node *rb_old, struct rb_node *rb_new)
 340   {
 341         struct interval_tree_node *old =
 342                 rb_entry(rb_old, struct interval_tree_node, rb);
 343         struct interval_tree_node *new =
 344                 rb_entry(rb_new, struct interval_tree_node, rb);
 345
 346         new->__subtree_last = old->__subtree_last;
 347   }
 348
 349   static void augment_rotate(struct rb_node *rb_old, struct rb_node *rb_new)
 350   {
 351         struct interval_tree_node *old =
 352                 rb_entry(rb_old, struct interval_tree_node, rb);
 353         struct interval_tree_node *new =
 354                 rb_entry(rb_new, struct interval_tree_node, rb);
 355
 356         new->__subtree_last = old->__subtree_last;
 357         old->__subtree_last = compute_subtree_last(old);
 358   }
 359
 360   static const struct rb_augment_callbacks augment_callbacks = {
 361         augment_propagate, augment_copy, augment_rotate
 362   };
 363
 364   void interval_tree_insert(struct interval_tree_node *node,
 365                             struct rb_root *root)
 366   {
 367         struct rb_node **link = &root->rb_node, *rb_parent = NULL;
 368         unsigned long start = node->start, last = node->last;
 369         struct interval_tree_node *parent;
 370
 371         while (*link) {
 372                 rb_parent = *link;
 373                 parent = rb_entry(rb_parent, struct interval_tree_node, rb);
 374                 if (parent->__subtree_last < last)
 375                         parent->__subtree_last = last;
 376                 if (start < parent->start)
 377                         link = &parent->rb.rb_left;
 378                 else
 379                         link = &parent->rb.rb_right;
 380         }
 381
 382         node->__subtree_last = last;
 383         rb_link_node(&node->rb, rb_parent, link);
 384         rb_insert_augmented(&node->rb, root, &augment_callbacks);
 385   }
 386
 387   void interval_tree_remove(struct interval_tree_node *node,
 388                             struct rb_root *root)
 389   {
 390         rb_erase_augmented(&node->rb, root, &augment_callbacks);
 391   }