这一章是对第十三章红黑树的扩张（PS：关于红黑树的介绍见链接）。在现实应用中我们经常需要在一些数据结构（链表、二叉树）上添加一些特性来解决问题。以前看书的时候从没有认真看过这一章，老是觉得没什么用。这次认真的看完、思考后，觉得真心不错。之前老是对扩张数据结构没什么概念，在解决某些问题的时候没有考虑使用某些算法或者数据结构的扩张去解决问题。第一是自己对算法和数据结构的认识还不够深入；第二是没有结合问题的特性和某些算法或者数据结构的特性来解决问题。以后要多加注意。
顺序统计树
顺序统计树是在红黑树的上添加一个size特性，每个结点都含有size域，size域的值为以该点为根的子树的结点数（包括根结点），即子树的大小。如下图所示。
图中忽略了NIL结点（哨兵），该结点的size域为0。
size域值的计算公式：size[x] = size[left[x]] + size[right[x]] + 1
首先来看在添加size域后，插入和删除结点的过程中如何维持它的特性。
插入操作：
红黑树的插入是有两个步骤：一、从根结点开始，沿着树下降，找到合适的位置并将新结点插入；二、从新结点开始沿着树上升，需要的时候修改结点的颜色和进行旋转操作以保持红黑树的性质。
那么从根结点到新结点插入的父结点的路上的结点都受到新结点的影响，它们的size的值应该要增加1（新结点的size值为1）。然后再进行旋转，旋转会影响size域的值，那么在旋转操作上添加调整size域的操作。（如图所示）
左旋转操作修改后代码如下：
1 /* 2 * x结点上进行左旋转，y结点（x结点的右儿子）的左儿子成为x结点的新右儿子 3 * x结点成为y结点的左儿子的新父结点 4 * x结点的父结点成为y结点的新父结点，y结点成为x结点的新父结点 5 * x结点成为y结点的新左儿子 6 */ 7 void Left_Rotate(RB_Tree *T, RB_TreeNode *x){ 8 RB_TreeNode *y = x->right; //x点右儿子 9 x->right = y->left; //y结点的左儿子会成为x结点的右儿子 10 if(y->left != NIL) 11 y->left->parent = x; //如果y有左儿子,y的左儿子的父结点为x 12 y->parent = x->parent; 13 if(x->parent == NIL) 14 T->root = y; //如果x的父结点为哨兵，说明x为根结点，则y成为根结点 15 else if(x == x->parent->left) 16 x->parent->left = y; 17 else 18 x->parent->right = y; //判断x为其父结点的左、右儿子，y成为x父结点对应的儿子 19 y->left = x; //y的左儿子为x 20 x->parent = y; //x的父结点为y 21 22 /*调整size域*/ 23 y->size = x->size; 24 x->size = x->left->size + x->right->size + 1; 25 }
插入操作修改后代码如下：
1 /* 2 * 插入函数，注意插入结点与其在树中对应的父结点的链接（需要记录父结点）。 3 * 从根结点出发，不停用当前结点与插入的值比较，如果当前结点的值比较大就往当前结点的左儿子走，相反就往右儿子走，直到当前结点为空， 4 * 在过程中记录当前结点的父结点。 5 * 运行时间为O(h),h为树的高度。因为整个过程是一条沿着根结点下降的路径。 6 */ 7 void RB_Insert(RB_Tree *T, int key){ 8 RB_TreeNode *z; 9 z = (RB_TreeNode *)malloc(sizeof(RB_TreeNode)); //新建结点 10 z->value = key; 11 z->color = RED; 12 z->parent = z->left = z->right = NIL; 13 z->size = 1; 14 RB_TreeNode *x = T->root; 15 RB_TreeNode *y = NIL; 16 while(x != NIL){ 17 y = x; 18 x->size += 1; 19 if(x->value < key) 20 x = x->right; 21 else 22 x = x->left; 23 } 24 z->parent = y; 25 if(y == NIL){ 26 T->root = z; 27 T->root->parent = NIL; 28 T->root->parent->color = BLACK; 29 T->root->size = 1; 30 } 31 else if(z->value < y->value) 32 y->left = z; 33 else 34 y->right = z; 35 RB_Insert_Fixup(T, z); //插入调整，维持红黑性质 36 }
增加新结点从根结点到叶子的遍历的路上总共有O(lgn)个结点，所以维护size域的额外代价为O(lgn)。
删除操作：
红黑树的删除也是两个步骤：一、查找真正要删除的结点；二、进行调整以维护红黑树的性质。
对于要删除的结点，它的父结点到根结点的路径上的所有结点的size域都会受到影响。所以要遍历删除结点到根结点的路径，并减少每个结点的size值。如果需要的时候进行旋转操作，维护红黑树的性质和调整size域。
删除操作修改后代码如下：
1 /* 2 * 删除结点函数，首先要确定真正删除的结点是那个。 3 * 如果z没有子结点，直接将z的父结点对应的指针指向NULL 4 * 如果z只有一个子节点，直接将z的父结点对应的指针指向z的子结点 5 * 如果z有两个子结点，实际上要删除的不是z，而是z的后继，，再用z的后继的内容代替z的内容 6 */ 7 8 void RB_Delete(RB_Tree *T, RB_TreeNode *z){ 9 RB_TreeNode *x = NULL; 10 RB_TreeNode *y = NULL; 11 RB_TreeNode *p = NULL; 12 13 if(z->left == NIL || z->right == NIL) 14 y = z; 15 else 16 y = RB_Tree_Successor(z); 17 if(y->left != NIL) 18 x = y->left; 19 else 20 x = y->right; 21 x->parent = y->parent; 22 if(y->parent == NIL) 23 T->root = x; 24 else if(y == y->parent->left) 25 y->parent->left = x; 26 else 27 y->parent->right = x; 28 29 /* 从删除结点遍历一条路径到根结点，并减少size值*/ 30 p = y; 31 while(p != T->root){ 32 p->parent->size = p->parent->size - 1; 33 p = p->parent; 34 } 35 36 if(y != z) 37 z->value = y->value; 38 if(y->color == BLACK) 39 RB_Delete_Fixup(T, x); //当实际要删除的结点y为黑色时才需要进行调整 40 }
从删除结点遍历到根结点，该路径的有O(lgn)个结点，所以维护size域的额外代价为O(lgn)。
接着我们来看通过添加size域可以帮助我们在O(lgn)时间内确定：一、任意的顺序统计量；二、一个元素在集合的位置是多少。
检索具有给定排序的元素：
对于x结点，size[left[x]]为以x为根结点的子树进行中序遍历时排在x之前的结点的个数，那么size[left[x]] + 1就是以x为根的子树中x的排序。
查找在某个集合里第i个小的关键字的结点的指针。
首先从根结点开始查询，如果当前子树的根结点的size[left[x]] + 1的值等于排序i，那么当前的子树的根结点wei第i小元素。如果i小于size[left[x]] + 1，那么第i小元素在当前子树的左子树中；如果i大于size[left[x]] + 1，那么第i小元素在在当前子树的右子树中，并且为右子树中为第（i-size[left[x]] + 1）小元素。（这个与第九章的选择方法差不多：第九章戳这里）。
代码如下：
1 RB_TreeNode * os_select(RB_TreeNode *x, int i){ 2 int r = x->left->size + 1; 3 if(i == r) 4 return x; 5 else if(i < r){ 6 return os_select(x->left, i); 7 } 8 else{ 9 return os_select(x->right, i-r); 10 } 11 }
最坏情况为从根结点遍历到叶结点，因为红黑树的高度为O(lgn)，所以经过的结点数为O(lgn)，所以运行时间为O(lgn)。
确定一个元素的秩：
给定一个结点x的指针，返回其在树中中序遍历后的到的线性位置。
x的秩为中序遍历后排在x之前的结点个数加上一。
代码如下：
1 int os_rank(RB_Tree *T, RB_TreeNode *x){ 2 int r = x->left->size + 1; 3 RB_TreeNode *y = x; 4 while(y != T->root){ 5 if(y == y->parent->right){ 6 r += (y->parent->left->size + 1); 7 } 8 y = y->parent; 9 } 10 return r; 11 }
最坏情况也是从根结点遍历到叶结点，所以运行时间为O(lgn)。
全部代码如下：
1 /* 2 * ===================================================================================== 3 * 4 * Filename: order_statistic_tree.c 5 * 6 * Description: 7 * 8 * Version: 1.0 9 * Created: 12/01/2013 05:21:02 PM 10 * Revision: none 11 * Compiler: gcc 12 * 13 * Author: alan (), alan19920626@gmail.com 14 * Organization: 15 * 16 * ===================================================================================== 17 */ 18 19 20 #include <stdio.h> 21 #include <stdlib.h> 22 23 #define RED 1 24 #define BLACK 0 25 26 typedef struct RB_TreeNode { 27 int value; 28 int color; 29 int size; 30 struct RB_TreeNode * parent; 31 struct RB_TreeNode * left; 32 struct RB_TreeNode * right; 33 }RB_TreeNode; //红黑树结点结构体 34 35 typedef struct RB_Tree { 36 RB_TreeNode * root; 37 }RB_Tree; //红黑树结构体，根结点 38 39 RB_TreeNode NILL = { -1, BLACK, 0, NULL, NULL, NULL }; 40 RB_TreeNode *NIL = &NILL; //NIL结点指针 41 42 void Left_Rotate(RB_Tree *T, RB_TreeNode *x); 43 44 void Right_Rotate(RB_Tree *T, RB_TreeNode *x); 45 46 void RB_Insert(RB_Tree *T, int key); 47 48 void RB_Insert_Fixup(RB_Tree *T, RB_TreeNode *z); 49 50 void RB_Delete(RB_Tree *T, RB_TreeNode *z); 51 52 void RB_Delete_Fixup(RB_Tree *T, RB_TreeNode *x); 53 54 RB_TreeNode * RB_Search(RB_TreeNode *x, int key); 55 56 RB_TreeNode * RB_Tree_Minimum(RB_TreeNode *x); 57 58 RB_TreeNode * RB_Tree_Maximum(RB_TreeNode *x); 59 60 RB_TreeNode * RB_Tree_Successor(RB_TreeNode *x); 61 62 RB_TreeNode * RB_Tree_Predecesor(RB_TreeNode *x); 63 64 void Inorder_RB_Tree_Walk(RB_TreeNode *x); 65 66 void free_men(RB_TreeNode *x); 67 68 RB_TreeNode * os_select(RB_TreeNode *x, int i); 69 70 int os_rank(RB_Tree *T, RB_TreeNode *x); 71 72 int main(){ 73 RB_Tree *T; 74 T->root = NIL; 75 76 int n, value, i; 77 scanf("%d", &n); 78 for(i = 1; i<= n; i++){ 79 scanf("%d", &value); 80 RB_Insert(T, value); 81 Inorder_RB_Tree_Walk(T->root); 82 printf(" "); 83 } 84 RB_TreeNode *s = RB_Search(T->root, 3); 85 if(s != NIL) 86 printf("%d is exists! ", s->value); 87 /*Inorder_RB_Tree_Walk(T->root); 88 89 printf(" ");*/ 90 91 printf("%d ", os_select(T->root, 3)->value); 92 93 printf("%d ", os_rank(T, s)); 94 95 //printf("%d ", RB_Tree_Minimum(T->root)->value); 96 //printf("%d ", RB_Tree_Maximum(T->root)->value); 97 //printf("%d ", RB_Tree_Successor(s)->value); 98 //printf("%d ", RB_Tree_Predecesor(s)->value); 99 RB_Delete(T, s); 100 Inorder_RB_Tree_Walk(T->root); 101 printf(" "); 102 103 return 0; 104 } 105 106 /* 107 * x结点上进行左旋转，y结点（x结点的右儿子）的左儿子成为x结点的新右儿子 108 * x结点成为y结点的左儿子的新父结点 109 * x结点的父结点成为y结点的新父结点，y结点成为x结点的新父结点 110 * x结点成为y结点的新左儿子 111 */ 112 void Left_Rotate(RB_Tree *T, RB_TreeNode *x){ 113 RB_TreeNode *y = x->right; //x点右儿子 114 x->right = y->left; //y结点的左儿子会成为x结点的右儿子 115 if(y->left != NIL) 116 y->left->parent = x; //如果y有左儿子,y的左儿子的父结点为x 117 y->parent = x->parent; 118 if(x->parent == NIL) 119 T->root = y; //如果x的父结点为哨兵，说明x为根结点，则y成为根结点 120 else if(x == x->parent->left) 121 x->parent->left = y; 122 else 123 x->parent->right = y; //判断x为其父结点的左、右儿子，y成为x父结点对应的儿子 124 y->left = x; //y的左儿子为x 125 x->parent = y; //x的父结点为y 126 127 /*调整size域*/ 128 y->size = x->size; 129 x->size = x->left->size + x->right->size + 1; 130 } 131 132 /* 133 * x结点上进行右旋转，y结点（x结点的左儿子）的右儿子成为x结点的新左儿子 134 * x结点成为y结点的右儿子的新父结点 135 * x结点的父结点成为y结点的新父结点，y结点成为x结点的新父结点 136 * x结点成为y结点的新右儿子 137 * PS：代码的解释可参照左旋转 138 */ 139 void Right_Rotate(RB_Tree *T, RB_TreeNode *x){ 140 RB_TreeNode *y = x->left; 141 x->left = y->right; 142 if(y->right != NIL) 143 y->right->parent = x; 144 y->parent = x->parent; 145 if(x->parent == NIL) 146 T->root = y; 147 else if(x == x->parent->left) 148 x->parent->left = y; 149 else 150 x->parent->right = y; 151 y->right = x; 152 x->parent = y; 153 154 /* */ 155 y->size = x->size; 156 x->size = x->left->size + x->right->size + 1; 157 } 158 159 /* 160 * 插入函数，注意插入结点与其在树中对应的父结点的链接（需要记录父结点）。 161 * 从根结点出发，不停用当前结点与插入的值比较，如果当前结点的值比较大就往当前结点的左儿子走，相反就往右儿子走，直到当前结点为空， 162 * 在过程中记录当前结点的父结点。 163 * 运行时间为O(h),h为树的高度。因为整个过程是一条沿着根结点下降的路径。 164 */ 165 void RB_Insert(RB_Tree *T, int key){ 166 RB_TreeNode *z; 167 z = (RB_TreeNode *)malloc(sizeof(RB_TreeNode)); //新建结点 168 z->value = key; 169 z->color = RED; 170 z->parent = z->left = z->right = NIL; 171 z->size = 1; 172 RB_TreeNode *x = T->root; 173 RB_TreeNode *y = NIL; 174 while(x != NIL){ 175 y = x; 176 x->size += 1; 177 if(x->value < key) 178 x = x->right; 179 else 180 x = x->left; 181 } 182 z->parent = y; 183 if(y == NIL){ 184 T->root = z; 185 T->root->parent = NIL; 186 T->root->parent->color = BLACK; 187 T->root->size = 1; 188 } 189 else if(z->value < y->value) 190 y->left = z; 191 else 192 y->right = z; 193 RB_Insert_Fixup(T, z); //插入调整，维持红黑性质 194 } 195 196 /* 197 * 插入调整，维持红黑性质 198 */ 199 void RB_Insert_Fixup(RB_Tree *T, RB_TreeNode *z){ 200 while(z->parent->color == RED){ //如果z结点的父结点为黑色，就不用进入3种情况的处理 201 if(z->parent == z->parent->parent ->left){ //z的父结点为左儿子的情况 202 RB_TreeNode *y = z->parent->parent->right; 203 if(y->color == RED){ //情况1 204 z->parent->color = BLACK; 205 y->color = BLACK; 206 z->parent->parent->color = RED; 207 z = z->parent->parent; 208 } 209 else { 210 if(z == z->parent->right){ //情况2 211 z = z->parent; 212 Left_Rotate(T, z); //左旋转，情况2变为3 213 } 214 z->parent->color = BLACK; //情况3 215 z->parent->parent->color = RED; 216 Right_Rotate(T, z->parent->parent); //右选择解决违反性质4 217 } 218 } 219 else{ 220 RB_TreeNode *y = z->parent->parent->left; //z的结点为右儿子的情况 221 if(y->color == RED){ //情况1 222 z->parent->color = BLACK; 223 y->color = BLACK; 224 z->parent->parent->color = RED; 225 z = z->parent->parent; 226 } 227 else{ 228 if(z == z->parent->left){ //情况2 229 z = z->parent; 230 Right_Rotate(T, z); //右旋转，情况2变为情况3 231 } 232 z->parent->color = BLACK; //情况3 233 z->parent->parent->color = RED; 234 Left_Rotate(T, z->parent->parent); //左旋转解决违反性质4 235 } 236 } 237 } 238 T->root->color = BLACK; //如果红黑树T的根结点为红色就会变成黑色，如果是黑色变成黑色也没影响 239 } 240 241 /* 242 * 删除结点函数，首先要确定真正删除的结点是那个。 243 * 如果z没有子结点，直接将z的父结点对应的指针指向NULL 244 * 如果z只有一个子节点，直接将z的父结点对应的指针指向z的子结点 245 * 如果z有两个子结点，实际上要删除的不是z，而是z的后继，，再用z的后继的内容代替z的内容 246 */ 247 248 void RB_Delete(RB_Tree *T, RB_TreeNode *z){ 249 RB_TreeNode *x = NULL; 250 RB_TreeNode *y = NULL; 251 RB_TreeNode *p = NULL; 252 253 if(z->left == NIL || z->right == NIL) 254 y = z; 255 else 256 y = RB_Tree_Successor(z); 257 if(y->left != NIL) 258 x = y->left; 259 else 260 x = y->right; 261 x->parent = y->parent; 262 if(y->parent == NIL) 263 T->root = x; 264 else if(y == y->parent->left) 265 y->parent->left = x; 266 else 267 y->parent->right = x; 268 269 /* 从删除结点遍历一条路径到根结点，并减少size值*/ 270 p = y; 271 while(p != T->root){ 272 p->parent->size = p->parent->size - 1; 273 p = p->parent; 274 } 275 276 if(y != z) 277 z->value = y->value; 278 if(y->color == BLACK) 279 RB_Delete_Fixup(T, x); //当实际要删除的结点y为黑色时才需要进行调整 280 } 281 282 /* 283 * 删除调整，使红黑树维持红黑性质 284 */ 285 void RB_Delete_Fixup(RB_Tree *T, RB_TreeNode *x){ 286 287 /* 288 RB_TreeNode *p = x; 289 while(p != T->root){ 290 p->parent->size = p->parent->size - 1; 291 p = p->parent; 292 } 293 */ 294 while(x != T->root && x->color == BLACK){ //当x结点为根结点或者x的颜色为红色（即为红黑， 实际上额外黑色没有直接加上去，只是默认x节点有一重额外的黑色） 295 if(x == x->parent->left){ //x为左儿子情况 296 RB_TreeNode *w = x->parent->right; 297 if(w->color == RED){ //情况1 298 w->color = BLACK; 299 x->parent->color = RED; 300 Left_Rotate(T, x->parent); //左旋转，使得情况1转换成情况2、3或4 301 w = x->parent->right; 302 } 303 304 if(w->left->color == BLACK && w->right->color == BLACK){ //情况2 305 w->color = RED; //修改颜色 306 x = x->parent; //上移 307 } 308 else{ 309 if(w->right->color == BLACK){ //情况3 310 w->left->color = BLACK; 311 w->color = RED; 312 Right_Rotate(T, w); //右旋转，情况3转换成情况4 313 w = x->parent->right; 314 } 315 w->color = x->parent->color; 316 x->parent->color = BLACK; 317 w->right->color = BLACK; 318 Left_Rotate(T, x->parent); //左旋转，去掉x的额外黑色 319 x = T->root; //使循环结束 320 } 321 322 } 323 else{ //x为右儿子情况（PS：下文的注释参考上文） 324 RB_TreeNode *w = x->parent->left; 325 if(w->color == RED){ 326 w->color = BLACK; 327 x->parent->color = RED; 328 Right_Rotate(T, x->parent); 329 w = x->parent->left; 330 } 331 332 if(w->left->color == BLACK && w->right->color == BLACK){ 333 w->color = RED; 334 x = x->parent; 335 } 336 else { 337 if(w->left->color == BLACK){ 338 w->right->color = BLACK; 339 w->color = RED; 340 Left_Rotate(T, w); 341 w = x->parent->left; 342 } 343 w->color = x->parent->color; 344 x->parent->color = BLACK; 345 w->left->color = BLACK; 346 Right_Rotate(T, x->parent); 347 x = T->root; 348 } 349 } 350 } 351 } 352 353 354 RB_TreeNode * RB_Search(RB_TreeNode *x, int key){ 355 if(x->value == key || x == NIL) 356 return x; 357 if(x->value > key) 358 RB_Search(x->left, key); 359 else 360 RB_Search(x->right, key); 361 } 362 363 RB_TreeNode * RB_Tree_Minimum(RB_TreeNode *x){ 364 RB_TreeNode *r = x; 365 while(r->left != NIL) 366 r = r->left; 367 return r; 368 } 369 370 RB_TreeNode * RB_Tree_Maximum(RB_TreeNode *x){ 371 RB_TreeNode *r = x; 372 while(r->left != NIL) 373 r = r->left; 374 return r; 375 } 376 377 RB_TreeNode * RB_Tree_Successor(RB_TreeNode *x){ 378 RB_TreeNode *r = x; 379 if(r->right != NIL) 380 return RB_Tree_Minimum(r->right); 381 RB_TreeNode *y = r->parent; 382 while(y != NIL && r == y->right){ 383 r = y; 384 y = y->parent; 385 } 386 return y; 387 } 388 RB_TreeNode * RB_Tree_Predecesor(RB_TreeNode *x){ 389 RB_TreeNode *r = x; 390 if(r->left != NIL) 391 return RB_Tree_Maximum(r->left); 392 RB_TreeNode *y = r->parent; 393 while(y != NIL && r == y->left){ 394 r = y; 395 y = y->parent; 396 } 397 return y; 398 } 399 400 void Inorder_RB_Tree_Walk(RB_TreeNode *x){ 401 if(x != NIL){ 402 Inorder_RB_Tree_Walk(x->left); 403 printf("%d : ", x->value); 404 if(x->color == 1) 405 printf("red "); 406 else 407 printf("black "); 408 printf("pos(%d) ", x->size); 409 Inorder_RB_Tree_Walk(x->right); 410 } 411 } 412 413 void free_men(RB_TreeNode *x){ 414 if(x != NIL){ 415 free_men(x->left); 416 free_men(x->right); 417 free(x); 418 } 419 } 420 421 RB_TreeNode * os_select(RB_TreeNode *x, int i){ 422 int r = x->left->size + 1; 423 if(i == r) 424 return x; 425 else if(i < r){ 426 return os_select(x->left, i); 427 } 428 else{ 429 return os_select(x->right, i-r); 430 } 431 } 432 433 int os_rank(RB_Tree *T, RB_TreeNode *x){ 434 int r = x->left->size + 1; 435 RB_TreeNode *y = x; 436 while(y != T->root){ 437 if(y == y->parent->right){ 438 r += (y->parent->left->size + 1); 439 } 440 y = y->parent; 441 } 442 return r; 443 }
测试结果：
lancelot@debian:~/Code/CLRS/Chapter14$ ./a.out 10 7 3 9 8 2 6 4 10 5 1 7 : black pos(1) 3 : red pos(1) 7 : black pos(2) 3 : red pos(1) 7 : black pos(3) 9 : red pos(1) 3 : black pos(1) 7 : black pos(4) 8 : red pos(1) 9 : black pos(2) 2 : red pos(1) 3 : black pos(2) 7 : black pos(5) 8 : red pos(1) 9 : black pos(2) 2 : red pos(1) 3 : black pos(3) 6 : red pos(1) 7 : black pos(6) 8 : red pos(1) 9 : black pos(2) 2 : black pos(1) 3 : red pos(4) 4 : red pos(1) 6 : black pos(2) 7 : black pos(7) 8 : red pos(1) 9 : black pos(2) 2 : black pos(1) 3 : red pos(4) 4 : red pos(1) 6 : black pos(2) 7 : black pos(8) 8 : red pos(1) 9 : black pos(3) 10 : red pos(1) 2 : black pos(1) 3 : red pos(5) 4 : red pos(1) 5 : black pos(3) 6 : red pos(1) 7 : black pos(9) 8 : red pos(1) 9 : black pos(3) 10 : red pos(1) 1 : red pos(1) 2 : black pos(2) 3 : red pos(6) 4 : red pos(1) 5 : black pos(3) 6 : red pos(1) 7 : black pos(10) 8 : red pos(1) 9 : black pos(3) 10 : red pos(1) 3 is exists! 1 : red pos(1) 2 : black pos(2) 3 : red pos(6) 4 : red pos(1) 5 : black pos(3) 6 : red pos(1) 7 : black pos(10) 8 : red pos(1) 9 : black pos(3) 10 : red pos(1) 3 3 1 : red pos(1) 2 : black pos(2) 4 : red pos(5) 5 : black pos(2) 6 : red pos(1) 7 : black pos(9) 8 : red pos(1) 9 : black pos(3) 10 : red pos(1)
如何扩张数据结构：
一、选择基础的数据结构
二、确定要在基础数据结构中添加哪些信息（根据需要）
三、验证可用基础数据结构上的基础修改操作来维护新添加的信息
四、设计新的操作
-----------------------------------------------------------------日后补上区间树----------------------------------------
-------------------------------------------吐槽--------------------------------------------------------
断了几个月的算法导论学习记录终于又要继续，之前想只把接下来的看看就算了，但是只是看看老是觉得学得不好，所以还是继续填坑算了
还有很多内容没啃透。。。。。。。。。。。。。慢慢一步一步学。。。。。。。。。。。。。。。。
算法导论的博客能更新真真真真是很开心。。。。Go on fighting!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
---------------------------------------------------------------------------------------------------------