码迷，mamicode.com
首页 > 其他好文 > 详细

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

时间：2014-12-03 14:13:13      阅读：355      评论：0      收藏：0      [点我收藏+]

标签：des   blog   http   io   ar   color   os   使用   sp   

菜鸟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: }

    bubuko.com,布布扣

    如果有相等的结点，会直接被覆盖，如上图插入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: }

     

    运行结果：

    bubuko.com,布布扣

    -

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

标签：des   blog   http   io   ar   color   os   使用   sp   

原文地址：http://www.cnblogs.com/0x2D-0x22/p/4139789.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！