菜鸟nginx源码剖析数据结构篇（四）红黑树ngx_rbtree_t

菜鸟nginx源码剖析数据结构篇（四）红黑树ngx_rbtree_t

• Author：Echo Chen（陈斌）

• Email：chenb19870707@gmail.com

• Blog：Blog.csdn.net/chen19870707

• Date：October 27h, 2014

   

   

  1.ngx_rbtree优势和特点

   

      ngx_rbtree是一种使用红黑树实现的关联容器，关于红黑树的特性，在《手把手实现红黑树》已经详细介绍，这里就只探讨ngx_rbtree与众不同的地方；ngx_rbtree红黑树容器中的元素都是有序的，支持快速索引，插入，删除操作，也支持范围查询，遍历操作，应用非常广泛。

   

  2.源代码位置

   

  头文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_rbtree.h

  源文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_rbtree.c

   

  3.数据结构定义

   

  可以看到ngx_rbtree的结点ngx_rbtree_node_t结构跟一般的红黑树差不多，都是由键值key、左孩子left、右孩子right、父亲结点parent、颜色值color，不同的是ngx_rbtree_node_t这里多了一个data，但根据官方文档记在，由于data只有一个字节，表示太少，很少使用到。

     1: typedef struct ngx_rbtree_node_s  ngx_rbtree_node_t;

     2:  

     3: struct ngx_rbtree_node_s {

     4:     ngx_rbtree_key_t       key;

     5:     ngx_rbtree_node_t     *left;

     6:     ngx_rbtree_node_t     *right;

     7:     ngx_rbtree_node_t     *parent;

     8:     u_char                 color;

     9:     u_char                 data;

    10: };

   

  ngx_rbtree_t的结构也与一般红黑树相同，右root结点和哨兵叶子结点（sentinel）组成，不同的是这里多了一个 函数指针inserter，它决定了在添加结点是新加还是替换。

   

     1: typedef struct ngx_rbtree_s  ngx_rbtree_t;

     2:  

     3: typedef void (*ngx_rbtree_insert_pt) (ngx_rbtree_node_t *root,

     4:     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

     5:  

     6: struct ngx_rbtree_s {

     7:     ngx_rbtree_node_t     *root;

     8:     ngx_rbtree_node_t     *sentinel;

     9:     ngx_rbtree_insert_pt   insert;

    10: };

   

  4.ngx_rbtree初始化 ngx_rbtree_init

   

  其中tree为ngx_rbtree_t类型，即为红黑树，s为ngx_rbtree_node_t，是rbtree的根节点，i即为上节提到的决定插入是新结点还是替换的函数指针。首先将根节点涂成 黑色（红黑树基本性质），然后把 红黑树的 根节点和 哨兵结点 都指向这个结点。

   

     1: #define ngx_rbtree_init(tree, s, i)                                           \

     2:     ngx_rbtree_sentinel_init(s);                                              \

     3:     (tree)->root = s;                                                         \

     4:     (tree)->sentinel = s;                                                     \

     5:     (tree)->insert = i

     6:  

     7: #define ngx_rbtree_sentinel_init(node)  ngx_rbt_black(node)

   

  5.ngx_rbtree 左旋 ngx_rbtree_left_rotate 和 右旋 ngx_rbtree_right_rotate

   

  可以看到，经典代码总是永恒的，ngx_rbtree的左旋右旋也是参考《算法导论》导论中的步骤和伪代码，对照我自己的实现的《手把手实现红黑树》，与我自己实现的左旋右旋代码基本一致，我图解了详细的过程，有不清楚的可以参考《手把手实现红黑树》。

   

     1: static ngx_inline void

     2: ngx_rbtree_left_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,

     3:     ngx_rbtree_node_t *node)

     4: {

     5:     ngx_rbtree_node_t  *temp;

     6:  

     7:     temp = node->right;

     8:     node->right = temp->left;

     9:  

    10:     if (temp->left != sentinel) {

    11:         temp->left->parent = node;

    12:     }

    13:  

    14:     temp->parent = node->parent;

    15:  

    16:     if (node == *root) {

    17:         *root = temp;

    18:  

    19:     } else if (node == node->parent->left) {

    20:         node->parent->left = temp;

    21:  

    22:     } else {

    23:         node->parent->right = temp;

    24:     }

    25:  

    26:     temp->left = node;

    27:     node->parent = temp;

    28: }

     1: static ngx_inline void

     2: ngx_rbtree_right_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,

     3:     ngx_rbtree_node_t *node)

     4: {

     5:     ngx_rbtree_node_t  *temp;

     6:  

     7:     temp = node->left;

     8:     node->left = temp->right;

     9:  

    10:     if (temp->right != sentinel) {

    11:         temp->right->parent = node;

    12:     }

    13:  

    14:     temp->parent = node->parent;

    15:  

    16:     if (node == *root) {

    17:         *root = temp;

    18:  

    19:     } else if (node == node->parent->right) {

    20:         node->parent->right = temp;

    21:  

    22:     } else {

    23:         node->parent->left = temp;

    24:     }

    25:  

    26:     temp->right = node;

    27:     node->parent = temp;

    28: }

  6.ngx_rbtree插入 ngx_rbtree_insert

  ngx_rbtree_insert也是分为两步，插入和调整，由于这两项都在《手把手实现红黑树》中做了详细解释，这里就不在啰嗦，这里值得一提的是，还记得node_rbtree_t 结构中的insert指针吗？这里就是通过这个函数指针来实现的插入。一个小小的技巧就实现了多态；并且它给出了 唯一值和时间类型的key 插入方法，可以满足一般需求，用户也可以实现自己的插入方法。

  1. void  
  2. ngx_rbtree_insert(ngx_thread_volatile ngx_rbtree_t *tree,  
  3.     ngx_rbtree_node_t *node)  
  4. {  
  5.     ngx_rbtree_node_t  **root, *temp, *sentinel;  
  6.   
  7.     /* a binary tree insert */  
  8.   
  9.     root = (ngx_rbtree_node_t **) &tree->root;  
  10.     sentinel = tree->sentinel;  
  11.   
  12.     if (*root == sentinel) {  
  13.         node->parent = NULL;  
  14.         node->left = sentinel;  
  15.         node->right = sentinel;  
  16.         ngx_rbt_black(node);  
  17.         *root = node;  
  18.   
  19.         return;  
  20.     }  
  21.   
  22.     tree->insert(*root, node, sentinel);  
  23.   
  24.     /* re-balance tree */  
  25.   
  26.     while (node != *root && ngx_rbt_is_red(node->parent)) {  
  27.   
  28.         if (node->parent == node->parent->parent->left) {  
  29.             temp = node->parent->parent->right;  
  30.   
  31.             if (ngx_rbt_is_red(temp)) {  
  32.                 ngx_rbt_black(node->parent);  
  33.                 ngx_rbt_black(temp);  
  34.                 ngx_rbt_red(node->parent->parent);  
  35.                 node = node->parent->parent;  
  36.   
  37.             } else {  
  38.                 if (node == node->parent->right) {  
  39.                     node = node->parent;  
  40.                     ngx_rbtree_left_rotate(root, sentinel, node);  
  41.                 }  
  42.   
  43.                 ngx_rbt_black(node->parent);  
  44.                 ngx_rbt_red(node->parent->parent);  
  45.                 ngx_rbtree_right_rotate(root, sentinel, node->parent->parent);  
  46.             }  
  47.   
  48.         } else {  
  49.             temp = node->parent->parent->left;  
  50.   
  51.             if (ngx_rbt_is_red(temp)) {  
  52.                 ngx_rbt_black(node->parent);  
  53.                 ngx_rbt_black(temp);  
  54.                 ngx_rbt_red(node->parent->parent);  
  55.                 node = node->parent->parent;  
  56.   
  57.             } else {  
  58.                 if (node == node->parent->left) {  
  59.                     node = node->parent;  
  60.                     ngx_rbtree_right_rotate(root, sentinel, node);  
  61.                 }  
  62.   
  63.                 ngx_rbt_black(node->parent);  
  64.                 ngx_rbt_red(node->parent->parent);  
  65.                 ngx_rbtree_left_rotate(root, sentinel, node->parent->parent);  
  66.             }  
  67.         }  
  68.     }  
  69.   
  70.     ngx_rbt_black(*root);  
  71. }  

  
  

  6.1 唯一值类型插入

   

  这个即为一般红黑树的插入方法，循环，如果插入的值比当前节点小，就进入左子树，否则进入右子树，直至遇到叶子结点，叶子节点就是要链入红黑树的位置。

     1: void

     2: ngx_rbtree_insert_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,

     3:     ngx_rbtree_node_t *sentinel)

     4: {

     5:     ngx_rbtree_node_t  **p;

     6:  

     7:     for ( ;; ) {

     8:  

     9:         p = (node->key < temp->key) ? &temp->left : &temp->right;

    10:  

    11:         if (*p == sentinel) {

    12:             break;

    13:         }

    14:  

    15:         temp = *p;

    16:     }

    17:  

    18:     *p = node;

    19:     node->parent = temp;

    20:     node->left = sentinel;

    21:     node->right = sentinel;

    22:     ngx_rbt_red(node);

    23: }

  

  如果有相等的结点，会直接被覆盖，如上图插入key为2的结点，则当tmp 为2的结点时，p为叶子遍历结束，这样p就会被覆盖为新的值。

   

  6.2 唯一时间类型插入

   

  唯一区别就是判断大小时，采用了两个值相减，避免溢出。

     1: typedef ngx_int_t   ngx_rbtree_key_int_t;

     2: void

     3: ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,

     4:     ngx_rbtree_node_t *sentinel)

     5: {

     6:     ngx_rbtree_node_t  **p;

     7:  

     8:     for ( ;; ) {

     9:  

    10:         /*

    11:          * Timer values

    12:          * 1) are spread in small range, usually several minutes,

    13:          * 2) and overflow each 49 days, if milliseconds are stored in 32 bits.

    14:          * The comparison takes into account that overflow.

    15:          */

    16:  

    17:         /*  node->key < temp->key */

    18:  

    19:         p = ((ngx_rbtree_key_int_t) (node->key - temp->key) < 0)

    20:             ? &temp->left : &temp->right;

    21:  

    22:         if (*p == sentinel) {

    23:             break;

    24:         }

    25:  

    26:         temp = *p;

    27:     }

    28:  

    29:     *p = node;

    30:     node->parent = temp;

    31:     node->left = sentinel;

    32:     node->right = sentinel;

    33:     ngx_rbt_red(node);

    34: }

   

   

  7.ngx_rbtree删除ngx_rbtree_delete

  也是按照《算法导论》上的步骤，先删除后调整，在《手把手实现红黑树》已介绍，请参考

     1: void

     2: ngx_rbtree_delete_delete(ngx_thread_volatile ngx_rbtree_t *tree,

     3:     ngx_rbtree_node_t *node)

     4: {

     5:     ngx_uint_t           red;

     6:     ngx_rbtree_node_t  **root, *sentinel, *subst, *temp, *w;

     7:  

     8:     /* a binary tree delete */

     9:  

    10:     root = (ngx_rbtree_node_t **) &tree->root;

    11:     sentinel = tree->sentinel;

    12:  

    13:     if (node->left == sentinel) {

    14:         temp = node->right;

    15:         subst = node;

    16:  

    17:     } else if (node->right == sentinel) {

    18:         temp = node->left;

    19:         subst = node;

    20:  

    21:     } else {

    22:         subst = ngx_rbtree_min(node->right, sentinel);

    23:  

    24:         if (subst->left != sentinel) {

    25:             temp = subst->left;

    26:         } else {

    27:             temp = subst->right;

    28:         }

    29:     }

    30:  

    31:     if (subst == *root) {

    32:         *root = temp;

    33:         ngx_rbt_black(temp);

    34:  

    35:         /* DEBUG stuff */

    36:         node->left = NULL;

    37:         node->right = NULL;

    38:         node->parent = NULL;

    39:         node->key = 0;

    40:  

    41:         return;

    42:     }

    43:  

    44:     red = ngx_rbt_is_red(subst);

    45:  

    46:     if (subst == subst->parent->left) {

    47:         subst->parent->left = temp;

    48:  

    49:     } else {

    50:         subst->parent->right = temp;

    51:     }

    52:  

    53:     if (subst == node) {

    54:  

    55:         temp->parent = subst->parent;

    56:  

    57:     } else {

    58:  

    59:         if (subst->parent == node) {

    60:             temp->parent = subst;

    61:  

    62:         } else {

    63:             temp->parent = subst->parent;

    64:         }

    65:  

    66:         subst->left = node->left;

    67:         subst->right = node->right;

    68:         subst->parent = node->parent;

    69:         ngx_rbt_copy_color(subst, node);

    70:  

    71:         if (node == *root) {

    72:             *root = subst;

    73:  

    74:         } else {

    75:             if (node == node->parent->left) {

    76:                 node->parent->left = subst;

    77:             } else {

    78:                 node->parent->right = subst;

    79:             }

    80:         }

    81:  

    82:         if (subst->left != sentinel) {

    83:             subst->left->parent = subst;

    84:         }

    85:  

    86:         if (subst->right != sentinel) {

    87:             subst->right->parent = subst;

    88:         }

    89:     }

    90:  

    91:     /* DEBUG stuff */

    92:     node->left = NULL;

    93:     node->right = NULL;

    94:     node->parent = NULL;

    95:     node->key = 0;

    96:  

    97:     if (red) {

    98:         return;

    99:     }

   100:  

   101:     /* a delete fixup */

   102:  

   103:     while (temp != *root && ngx_rbt_is_black(temp)) {

   104:  

   105:         if (temp == temp->parent->left) {

   106:             w = temp->parent->right;

   107:  

   108:             if (ngx_rbt_is_red(w)) {

   109:                 ngx_rbt_black(w);

   110:                 ngx_rbt_red(temp->parent);

   111:                 ngx_rbtree_left_rotate(root, sentinel, temp->parent);

   112:                 w = temp->parent->right;

   113:             }

   114:  

   115:             if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {

   116:                 ngx_rbt_red(w);

   117:                 temp = temp->parent;

   118:  

   119:             } else {

   120:                 if (ngx_rbt_is_black(w->right)) {

   121:                     ngx_rbt_black(w->left);

   122:                     ngx_rbt_red(w);

   123:                     ngx_rbtree_right_rotate(root, sentinel, w);

   124:                     w = temp->parent->right;

   125:                 }

   126:  

   127:                 ngx_rbt_copy_color(w, temp->parent);

   128:                 ngx_rbt_black(temp->parent);

   129:                 ngx_rbt_black(w->right);

   130:                 ngx_rbtree_left_rotate(root, sentinel, temp->parent);

   131:                 temp = *root;

   132:             }

   133:  

   134:         } else {

   135:             w = temp->parent->left;

   136:  

   137:             if (ngx_rbt_is_red(w)) {

   138:                 ngx_rbt_black(w);

   139:                 ngx_rbt_red(temp->parent);

   140:                 ngx_rbtree_right_rotate(root, sentinel, temp->parent);

   141:                 w = temp->parent->left;

   142:             }

   143:  

   144:             if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {

   145:                 ngx_rbt_red(w);

   146:                 temp = temp->parent;

   147:  

   148:             } else {

   149:                 if (ngx_rbt_is_black(w->left)) {

   150:                     ngx_rbt_black(w->right);

   151:                     ngx_rbt_red(w);

   152:                     ngx_rbtree_left_rotate(root, sentinel, w);

   153:                     w = temp->parent->left;

   154:                 }

   155:  

   156:                 ngx_rbt_copy_color(w, temp->parent);

   157:                 ngx_rbt_black(temp->parent);

   158:                 ngx_rbt_black(w->left);

   159:                 ngx_rbtree_right_rotate(root, sentinel, temp->parent);

   160:                 temp = *root;

   161:             }

   162:         }

   163:     }

   164:  

   165:     ngx_rbt_black(temp);

   166: }

   

  8.实战

   

  由于ngx_rbtree_t未牵涉到内存池，所以非常容易抽出来使用，如下为实现了插入、打印最小值、删除的例子

     1: #include <iostream>

     2: #include <algorithm>

     3: #include <pthread.h>

     4: #include <time.h>

     5: #include <stdio.h>

     6: #include <errno.h>

     7: #include <string.h>

     8: #include "ngx_queue.h"

     9: #include "ngx_rbtree.h"

    10:  

    11:  

    12: int main()

    13: {

    14:  

    15:     ngx_rbtree_t tree;

    16:     ngx_rbtree_node_t sentinel;

    17:  

    18:     ngx_rbtree_init(&tree,&sentinel,ngx_rbtree_insert_value);

    19:  

    20:     ngx_rbtree_node_t *rbnode = new ngx_rbtree_node_t[100];

    21:     for(int i = 99; i >= 0 ;i--)

    22:     {

    23:         rbnode[i].key = i;

    24:         rbnode[i].parent = NULL;

    25:         rbnode[i].left = NULL;

    26:         rbnode[i].right = NULL;

    27:         ngx_rbtree_insert(&tree,&rbnode[i]);

    28:     }

    29:  

    30:     for(int i = 0; i < 100;i++)

    31:     {

    32:          ngx_rbtree_node_t *p = ngx_rbtree_min(tree.root,&sentinel);

    33:          std::cout << p->key << "  ";

    34:          ngx_rbtree_delete(&tree,p);

    35:      }

    36:  

    37:  

    38:     delete[] rbnode;

    39:  

    40:     return 0;

    41: }

   

  运行结果：

  
  

  -

  Echo Chen：Blog.csdn.net/chen19870707

  -