标签：b树   b+树   红黑树   数据结构   

B-树

B-tree树即B树，B即Balanced，平衡的意思，B-树又称为多路平衡查找树。因为B树的原英文名称为B-tree，而国内很多人喜欢把B-tree译作B-树，其实，这是个非常不好的直译，很容易让人产生误解。如人们可能会以为B-树是一种树，而B树又是另一种树。而事实上是，B-tree就是指的B树。

一、定义

B-树是一种多路搜索树（并不一定是二叉的）

一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树。它或者是空树，或者是满足下列性质的树：

二、概念

1. 定义任意非叶子结点最多只有M个儿子；且M>2；

M=3的B-树

B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点。

三、特性

(1)根结点只有1个，关键字字数的范围[1,m-1]，分支数量范围[2,m]；

(2)除根以外的非叶结点，每个结点包含分支数范围[[m/2],m]，即关键字字数的范围是[[m/2]-1,m-1]，其中[m/2]表示取大于m/2的最小整数；

(3)非叶结点是由叶结点分裂而来的，所以叶结点关键字个数也满足[[m/2]-1,m-1]；

四、B树查找的算法思想

1、B-树的查找

B-树的查找过程：根据给定值查找结点和在结点的关键字中进行查找交叉进行。首先从根结点开始重复如下过程：

      若比结点的第一个关键字小，则查找在该结点第一个指针指向的结点进行；若等于结点中某个关键字，则查找成功；若在两个关键字之间，则查找在它们之间的指针指向的结点进行；若比该结点所有关键字大，则查找在该结点最后一个指针指向的结点进行；若查找已经到达某个叶结点，则说明给定值对应的数据记录不存在，查找失败。

2. B-树的插入

插入的过程分两步完成：

  （1）利用前述的B-树的查找算法查找关键字的插入位置。若找到，则说明该关键字已经存在，直接返回。否则查找操作必失败于某个最低层的非终端结点上。

  （2）判断该结点是否还有空位置。即判断该结点的关键字总数是否满足n<=m-1。若满足，则说明该结点还有空位置，直接把关键字k插入到该结点的合适位置上。若不满足，说明该结点己没有空位置，需要把结点分裂成两个。

分裂的方法是：生成一新结点。把原结点上的关键字和k按升序排序后，从中间位置把关键字（不包括中间位置的关键字）分成两部分。左部分所含关键字放在旧结点中，右部分所含关键字放在新结点中，中间位置的关键字连同新结点的存储位置插入到父结点中。如果父结点的关键字个数也超过（m-1），则要再分裂，再往上插。直至这个过程传到根结点为止。

3、B-树的删除

在B-树上删除关键字k的过程分两步完成：

   （1）利用前述的B-树的查找算法找出该关键字所在的结点。然后根据 k所在结点是否为叶子结点有不同的处理方法。

   （2）若该结点为非叶结点，且被删关键字为该结点中第i个关键字key[i]，则可从指针son[i]所指的子树中找出最小关键字Y，代替key[i]的位置，然后在叶结点中删去Y。

因此，把在非叶结点删除关键字k的问题就变成了删除叶子结点中的关键字的问题了。

在B-树叶结点上删除一个关键字的方法是

首先将要删除的关键字k直接从该叶子结点中删除。然后根据不同情况分别作相应的处理，共有三种可能情况：

（1）如果被删关键字所在结点的原关键字个数n>=ceil(m/2)，说明删去该关键字后该结点仍满足B-树的定义。这种情况最为简单，只需从该结点中直接删去关键字即可。

（2）如果被删关键字所在结点的关键字个数n等于ceil(m/2)-1，说明删去该关键字后该结点将不满足B-树的定义，需要调整。

调整过程为：如果其左右兄弟结点中有“多余”的关键字,即与该结点相邻的右（左）兄弟结点中的关键字数目大于ceil(m/2)-1。则可将右（左）兄弟结点中最小（大）关键字上移至双亲结点。而将双亲结点中小（大）于该上移关键字的关键字下移至被删关键字所在结点中。

（3）如果左右兄弟结点中没有“多余”的关键字，即与该结点相邻的右（左）兄弟结点中的关键字数目均等于ceil(m/2)-1。这种情况比较复杂。需把要删除关键字的结点与其左（或右）兄弟结点以及双亲结点中分割二者的关键字合并成一个结点,即在删除关键字后，该结点中剩余的关键字加指针，加上双亲结点中的关键字K_i一起，合并到A_i（是双亲结点指向该删除关键字结点的左（右）兄弟结点的指针）所指的兄弟结点中去。如果因此使双亲结点中关键字个数小于ceil(m/2)-1，则对此双亲结点做同样处理。以致于可能直到对根结点做这样的处理而使整个树减少一层。

总之，设所删关键字为非终端结点中的Ki，则可以指针Ai所指子树中的最小关键字Y代替Ki，然后在相应结点中删除Y。对任意关键字的删除都可以转化为对最下层关键字的删除。

如图示：

a、被删关键字Ki所在结点的关键字数目不小于ceil(m/2)，则只需从结点中删除Ki和相应指针Ai，树的其它部分不变。

b、被删关键字Ki所在结点的关键字数目等于ceil(m/2)-1，则需调整。调整过程如上面所述。

c、被删关键字Ki所在结点和其相邻兄弟结点中的的关键字数目均等于ceil(m/2)-1，假设该结点有右兄弟，且其右兄弟结点地址由其双亲结点指针Ai所指。则在删除关键字之后，它所在结点的剩余关键字和指针，加上双亲结点中的关键字Ki一起，合并到Ai所指兄弟结点中（若无右兄弟，则合并到左兄弟结点中）。如果因此使双亲结点中的关键字数目少于ceil(m/2)-1，则依次类推。

五、B-树的C语言描述

1、存储结构

2、插入

3、查找

六、B-树的C语言实现

七、复杂度分析

B-树查找包含两种基本动作：

     ●在B-树上查找结点

     ●在结点中找关键字

前一操作在磁盘上进行，后一操作在内存进行。因此查找效率主要由前一操作决定。在磁盘上查找的次数取决于关键字结点在B-树上的层次数。

定理：若n≥1，m≥3，则对任意一棵具有n个关键字的m阶B-树，其树高度h至多为log_t((n+1)/2)+1，t= ceil(m/2)。也就是说根结点到关键字所在结点的路径上涉及的结点数不超过log_t((n+1)/2)+1。推理如下：

B+树

B+ 树是一种树数据结构，是一个n叉树，每个节点通常有多个孩子，一颗B+树包含根节点、内部节点和叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上孩子节点的节点。

一、定义

3.所有的非终端结点可以看成是索引部分，结点中仅含其子树（根结点）中的最大（或最小）关键字。

B+树的查找

B+树的插入

B+树的删除

B+树的删除也仅在叶子结点进行，当叶子结点中的最大关键字被删除时，其在非终端结点中的值可以作为一个“分界关键字”存在。若因删除而使结点中关键字的个数少于m/2 （m/2结果取上界，如5/2结果为3）时，其和兄弟结点的合并过程亦和B-树类似。

三、B+树与B树的区别

一棵m阶的B+树和m阶的B树的异同点在于：

• 所有的叶子结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接。(而B 树的叶子节点并没有包括全部需要查找的信息)
• 所有的非终端结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字。(而B 树的非终节点也包含需要查找的有效信息)

四、B+树与操作系统的文件索引和数据库索引

为什么说B+树比B 树更适合实际应用中操作系统的文件索引和数据库索引？
B+树的磁盘读写代价更低

• B+树的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。如果把所有同一内部结点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。
  举个例子，假设磁盘中的一个盘块容纳16bytes，而一个关键字2bytes，一个关键字具体信息指针2bytes。一棵9阶B-tree(一个结点最多8个关键字)的内部结点需要2个盘快。而B+树内部结点只需要1个盘快。当需要把内部结点读入内存中的时候，B 树就比B+树多一次盘块查找时间(在磁盘中就是盘片旋转的时间)。
• B+树的查询效率更加稳定
  由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。

红黑树

红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。

它是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。

红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。

它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

一、性质

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:

性质1. 节点是红色或黑色。

性质2. 根节点是黑色。

性质3 每个叶节点（NIL节点，空节点）是黑色的。

性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

要知道为什么这些特性确保了这个结果，注意到性质4导致了路径不能有两个毗连的红色节点就足够了。最短的可能路径都是黑色节点，最长的可能路径有交替的红色和黑色节点。因为根据性质5所有最长的路径都有相同数目的黑色节点，这就表明了没有路径能多于任何其他路径的两倍长。

在很多树数据结构的表示中，一个节点有可能只有一个子节点，而叶子节点不包含数据。用这种范例表示红黑树是可能的，但是这会改变一些属性并使算法复杂。为此，本ul文中我们使用 "nil 叶子" 或"空(nl)叶子"，如上图所示，它不包含数据而只充当树在此结束的指示。这些节点在绘图中经常被省略，导致了这些树好象同上述原则相矛盾，而实际上不是这样。与此有关的结论是所有节点都有两个子节点，尽管其中的一个或两个可能是空叶子。

注意：由于红黑树也是二叉查找树，它们当中每一个节点的比较值都必须大于或等于在它的左子树中的所有节点，并且小于或等于在它的右子树中的所有节点。这确保红黑树运作时能够快速的在树中查找给定的值。

二. 数据结构定义

RBT数据结构在基本二叉树数据结构之上增加一个color和parent，color用于保存节点颜色，parent指向父节点。

[cpp] view plaincopyprint?

1. #define COLOR_RED 0  
2. #define COLOR_BLACK 1  
3.   
4. typedef int keyType;  
5.   
6. // 定义而二叉树节点数据结构  
7. struct BinaryTreeNode {  
8.     keyType key;      
9.     int color;  
10.     BinaryTreeNode* parent; // 保存父节点  
11.     BinaryTreeNode* left; // left child  
12.     BinaryTreeNode* right; // right child  
13. };  
14.   
15. // define red-black tree node  
16. typedef BinaryTreeNode rbnode;  
17.   
18. // define red-black tree  
19. typedef BinaryTreeNode rbtree;  

三、 插入Key

无论怎么样操作，性质1和性质3是始终能够保持的。新插入节点的时候，新节点的初始颜色为红色，这样可以不直接破坏性质5，这个时候可能性质4受到威胁，需要调整节点颜色或这左一些旋转等操作。假设新插入的节点为N，其父节点为P，祖父节点为G，叔父节点为U，下面具体分析一下插入新节点的各种情况。

情形1 、空树

当树为空的时候，直接将N节点设为黑色作为树的根节点返回。

情形2 、P为黑色节点

图中所示为N插入到P左孩子节点中，这个过程完全满足性质 1 - 5 的要求，并没有破坏 RBT 的规则，因此，此时即可停止检查，插入过程结束。

同理，若P为黑色节点，N插入后作为P的右孩子节点也不会破坏 RBT的规则。

（下面开始讨论 P 为红色 的情形，由 性质2 推导出 G 一定存在，根据性质 4，G一定是黑色）

情形3 、P为红色节点，U存在且为红色节点

这种情况下，将G变为红色，P和U变为黑色，这样维持了G为Root的子树内性质4和5，然后以G作为新的插入节点，从情形1开始迭代。

情形4 、P为红色节点，U不存在或者U为黑色

	（a） 若P在G的左侧，插入点N也在P的左侧 ------ LL 型 假设G的右侧有 路径有 x个黑色节点，则c有x个黑色节点，G为root的子树路径有x+1个黑色节点。 此时， 只需要以P为中心右旋，将P变为黑色，G变为红色，G的左子树替换为c，这样就可以继续保证以P为root的子树有x+1个黑色节点，检查停止。
	（b）若P在G的左侧，N在P的右侧  -----LR型 这时候先将节点P和节点N做调整，进行左旋，变化成（a）的形态，然后做一次右旋。到此，调整完毕。
图略	（c）若P在G的右侧，N在P的右侧 ----------RR型 情形和（a）正好相反，做一次左旋即可。
图略	（d）若P在G的右侧，N在P的左侧 ----------RL型 情形和（b）正好相反，先做做一次右旋，后进行一次左旋即可。

RBT插入算法过程代码如下：

[cpp] view plaincopyprint?

1. // 向右旋转  
2. void rb_right_rotate(rbnode* g) {  
3.     rbnode * p = g->left;  
4.     keyType k = g->key;  
5.     g->key = p->key;  
6.     p->key = k;  
7.     g->left = p->left;  
8.     if (NULL != p->left) {  
9.         p->left->parent = g;  
10.     }  
11.     p->left = p->right;  
12.     p->right = g->right;  
13.     if (NULL != g->right) {  
14.         g->right->parent = p;  
15.     }  
16.     g->right = p;  
17. }  
18.   
19. // 向左旋转  
20. void rb_left_rotate(rbnode* g) {  
21.     rbnode* p = g->right;  
22.     keyType k = g->key;  
23.     g->key = p->key;  
24.     p->key = k;  
25.     g->right = p->right;  
26.     if (NULL != p->right) {  
27.         p->right->parent = g;  
28.     }  
29.     p->right = p->left;  
30.     p->left = g->left;  
31.     if (NULL != g->left) {  
32.         g->left->parent = p;  
33.     }  
34.     g->left = p;  
35. }  
36.   
37. // check and adjust after insertion  
38. void rbt_insert_check(rbnode* node) {  
39.     // CASE 1 :  if the node equals the root  
40.     // set the color of the node black and return.  
41.     if (NULL == node->parent) {  
42.         node->color = COLOR_BLACK;  
43.         return;  
44.     }  
45.     // CASE 2 : when the parent of the node is black  
46.     // All features have been met, stop check and return  
47.     if (node->parent->color == COLOR_BLACK) {  
48.         return;  
49.     }  
50.   
51.     // Otherwise, the the parent node is RED, and this means the grandfather node exists.  
52.     rbnode* gf = node->parent->parent;  
53.     rbnode* uf = (gf->left == node->parent) ? gf->right : gf->left;  
54.   
55.     // CASE 3 : When the uncle node exists and it‘s RED  
56.     if (NULL != uf && uf->color == COLOR_RED) {  
57.         // set parent and uncle black, set grandfather red  
58.         node->parent->color = COLOR_BLACK;  
59.         uf->color = COLOR_BLACK;  
60.         gf->color = COLOR_RED;  
61.         // then re check the tree at grandfather node from CASE 1.  
62.         rbt_insert_check(gf);  
63.         return;  
64.     }  
65.   
66.     // CASE 4 : when the uncle is NULL or its color is Black.  
67.     if (node->parent == gf->left) { // the node in the left of its grandfather  
68.         // (a) LL model  
69.         if (node == node->parent->left) { // the node in the left of its parent  
70.             rb_right_rotate(gf);  
71.         }  
72.         // (b) LR model  
73.         else if (node == node->parent->right) { //the node in the right of its parent.  
74.             rb_left_rotate(node->parent);  
75.             rb_right_rotate(gf);  
76.         }  
77.     } else if (node->parent == gf->right) { //the node in the right of its grandfather  
78.         // (c) RR model  
79.         if (node == node->parent->right) { //the node in the right of its parent.  
80.             rb_left_rotate(gf);  
81.         }  
82.         // (d) RL model  
83.         else if (node == node->parent->left) { //the node in the left of its parent.  
84.             rb_right_rotate(node->parent);  
85.             rb_left_rotate(gf);  
86.         }  
87.     }  
88. }  
89.   
90. // 插入新的关键字  
91. int rbt_insert(rbtree* &tree, keyType key) {  
92.     if (NULL == tree) { // if the tree is NULL  
93.         tree = (rbtree*) malloc((sizeof(rbnode)));  
94.         tree->key = key;  
95.         tree->color = COLOR_BLACK;  
96.         tree->parent = tree->left = tree->right = NULL;  
97.         return 1;  
98.     }  
99.     // find insert point  
100.     rbnode *n = tree, *p = tree->parent;  
101.     while (NULL != n) {  
102.         if (key == n->key) {  
103.             return 0;  
104.         }  
105.         p = n;  
106.         n = (key > p->key) ? p->right : p->left;  
107.     }  
108.     // insert the node  
109.     n = (rbtree*) malloc((sizeof(rbnode)));  
110.     n->key = key;  
111.     n->color = COLOR_RED;  
112.     n->parent = p;  
113.     n->right = n->left = NULL;  
114.     ((key > p->key) ? p->right : p->left) = n;  
115.   
116.     // adjust the tree  
117.     rbt_insert_check(n);  
118.   
119.     return 1;  
120. }  

四、删除Key

从RBT中删除指定的Key时，需要重新调整树的形态使之满足红黑树的特性。下面来具体分析一下删除Key的过程。

（1）根据key找到要删除的节点Node：如果没有找到，直接返回，否则，进行下一步操作；

（2）如果Node有两个孩子节点，那么删除Node之后该如何放置其孩子节点呢？

           这个时候需要进行预处理，转化为删除只有一个孩子的节点的情形。

           找到Node的中序前驱（后继）节点，将前驱（后继）节点的值复制到Node中，Node指向前驱（后继）节点；

（3）到此步骤，Node确切的指示为待删除的节点，且Node最多只有一个孩子节点。

           删除Node节点，将Node的孩子节点顶替Node的位置.（注意Node为Root的情形）

（4）调整RBT树使其满足规定的5大特性。
           假设上一步中顶替上来的节点为 N ，其父节点为 P ，其兄弟节点为 S ，Sl 和 Sr 分别为 S 的左右孩子节点 ，假设 N 在 P 的左侧， 调整过程如下：
          （右侧与左侧对称，这里分析一种即可）

情形1 、N节点为红色

当N节点为红色的时候，由于左侧缺少一个黑色的节点，可以将N节点的颜色修改为黑色，这样即可从新满足性质5. 调整完毕。

情形2、S节点为红色

当S节点为红色节点时，则可以将P节点向左旋转，旋转之后P为红色，S为黑色，这个时候S-Sl这条简单路径黑色节点数目合法，S-P-Sl节点数目也合法，S-P-N路径黑色节点数目少一个。 相当于，P的左侧删除了一个黑色节点，应当重新调整 P，S，Sl，Sr所指向的节点，进行后续操作。 后续可能的情形为：3，5，6

情形3、P节点为红色，S，Sl，Sr为黑色

当P为红色，S为黑色，Sl和Sr均为黑色的时候，则可以简单的交换P节点和S节点的颜色，这样即可使各条简单路径的黑色节点数目和删除节点前相等。 调整完毕。

情形4、P，S，Sl，Sr均为黑色

当P、S、Sl、Sr均为黑色节点的时候，只需要简单的将S节点标记为红色，这样以P节点为根的个简单路径黑色节点数目比删除之前少一个。 因此，P相当与N的位置，从P的父节点开始递归进行调整。 （如果此时P为树的根节点，即可停止调整）

情形5、Sl为红色节点并且Sr为黑色

这种情况下，可以将Sl进行右旋操作，右旋之后，Sl为黑色，S为红色，Sr不变，这样保持P节点右子树中各简单路径黑色节点数目和旋转前一样。 这个时候，原来的S相当于Sl的位置，Sl相当与a，Sr相当与S。 更新S，Sl，Sr新指向的位置，进行下一步操作。 后续情形为：6.

情形6、Sr为红色

这时，将P节点做一次左旋操作，将Sr的颜色设置为黑色，P和S交换颜色，调整之后，各简单路径的黑色节点数目和删除节点之前一样。 此时调整结束。

[cpp] view plaincopyprint?

1. int is_black(rbnode * node) {  
2.     if (node == NULL) return 1;  
3.     if (node->color == COLOR_BLACK) return 1;  
4.     return 0;  
5. }  
6.   
7. // check and adjust after deletion  
8. void rbt_delete_check(rbnode* p, bool delLeft) {  
9.     rbnode * n = delLeft ? p->left : p->right;  
10.     // case 1: n is red  
11.     if (NULL != n && n->color == COLOR_RED) {  
12.         n->color = COLOR_BLACK;  
13.         return;  
14.     }  
15.     // else the other subtree of p at least has one more node.  
16.     rbnode * s = delLeft ? p->right : p->left;  
17.     rbnode * sl = s->left;  
18.     rbnode * sr = s->right;  
19.   
20.     // case 2 : S is red , p left rotate  
21.     if (s->color == COLOR_RED) {  
22.         if (delLeft) {  
23.             rb_left_rotate(p);  
24.         } else {  
25.             rb_right_rotate(p);  
26.         }  
27.         p = s;  
28.         s = delLeft ? sl : sr;  
29.         sl = s->left;  
30.         sr = s->right;  
31.     }  
32.     // Other cases : S is black  
33.     // when SL and SR  are black  
34.     if (is_black(sl) && is_black(sr)) {  
35.         // case 3 : P is red,  S SL and SR are black  
36.         if (!is_black(p)) {  
37.             p->color = COLOR_BLACK;  
38.             s->color = COLOR_RED;  
39.         }  
40.         // case 4: P ,S, SL and SR are black  
41.         else {  
42.             s->color = COLOR_RED;  
43.             if (NULL == p->parent) {  
44.                 return;  
45.             }  
46.             delLeft = (p == p->parent->left);  
47.             rbt_delete_check(p->parent, delLeft);  
48.         }  
49.         return;  
50.     }  
51.     // when SL and SR has red node  
52.     if (delLeft) {  
53.         if (is_black(sr)) {    // case 5(a) : delLeft is true and SR is black  
54.             rb_right_rotate(s);  
55.             sr = s->right;  
56.         }  
57.         rb_left_rotate(p);    // case 6(a) : rotate the p node  
58.         sr->color = COLOR_BLACK;  
59.     } else {  
60.         if (is_black(sl)) {    // case 5(b) : delLeft is false and SL is black  
61.             rb_left_rotate(s);  
62.             sl = s->left;  
63.         }  
64.         rb_right_rotate(p);    // case 6(b) : rotate the p node  
65.         sl->color = COLOR_BLACK;  
66.     }  
67. }  
68.   
69. // delete a key from the RBT  
70. int rbt_delete(rbtree* &tree, keyType key) {  
71.     if (NULL == tree) {  
72.         return 0;  
73.     }  
74.     // find the node  
75.     rbnode *curr, *temp;  
76.     for (curr = tree;;) {  
77.         if (key == curr->key) {  
78.             break;  
79.         }  
80.         curr = (key > curr->key) ? curr->right : curr->left;  
81.         if (NULL == curr) {  
82.             return 0;  
83.         }  
84.     }  
85.     // if the node to delete has two children  
86.     if (NULL != curr->left && NULL != curr->right) {  
87.         for (temp = curr->left; NULL != temp->right; temp = temp->right) {  
88.         }  
89.         curr->key = temp->key;  
90.         curr = temp;  
91.     }  
92.     if (NULL == curr->parent) { // it is the tree root  
93.         tree = (NULL == curr->left) ? curr->right : curr->left;  
94.         if (tree != NULL) {  
95.             tree->color = COLOR_BLACK;  
96.             tree->parent = NULL;  
97.         }  
98.         free(curr);  
99.         return 1;  
100.     }  
101.     // delete the node  
102.     rbnode* fa = curr->parent;  
103.     temp = (NULL == curr->left) ? curr->right : curr->left;  
104.     bool delLeft = (fa->left == curr);  
105.     if (NULL != temp) {  
106.         temp->parent = fa;  
107.     }  
108.     delLeft ? fa->left = temp : fa->right = temp;  
109.     if (curr->color != COLOR_RED) { // adjust after deletion  
110.         rbt_delete_check(fa, delLeft);  
111.     }  
112.     free(curr);  
113.     return 1;  
114. } 
     

B-树、B+树、红黑树

标签：b树   b+树   红黑树   数据结构   

原文地址：http://blog.csdn.net/lingling_1/article/details/46806733