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

最新推荐文章于 2022-11-16 10:34:02 发布
最新推荐文章于 2022-11-16 10:34:02 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： nginx 文章标签： 算法导论 源代码 数据结构 nginx 插入排序

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

一枪尽骚丶魂
关注
专栏目录
Nginx 红黑树结构 ngx_rbtree_t
关注校招求职，微信号：job_campus
01-07 2044
本文分析了 Nginx 红黑树的源码实现，其基本实现跟算法导论中的红黑树是一样的。
新秀nginx源代码分析数据结构篇（四）红黑树ngx_rbtree_t
weixin_34087301的博客
08-07 170
  新秀nginx源代码分析数据结构篇（四）红黑树ngx_rbtree_t   Author：Echo Chen（陈斌） Email：chenb19870707@gmail.com Blog：Blog.csdn.net/chen19870707 Date：October 27h, 2014     1.ngx_rbtree优势和特点       ngx...
nginx之ngx_rbtree
weixin_43352959的博客
08-12 293
nginx实现了一个红黑树的容器提供使用，定义在ngx_rbtree里面，这个容器相对简单，提供了插入，删除，初始化等方法。 ngx_rbtree.h: //ngx_rbtree_key为unsigned int或者int类型 typedef ngx_uint_t ngx_rbtree_key_t; typedef ngx_int_t ngx_rbtree_key_int_t; typedef struct ngx_rbtree_node_s ngx_rbtree_node_t; struct
10.nginx源码分析之数据结构：ngx__rbtree_t
linux_player_c（系统&开发）
10-31 651
nginx源码分析之数据结构：ngx__rbtree_t 除了之前介绍的list、array、queue等线性数据结构之外，nginx还提供了查询效率较高的红黑树结构，这种二叉平衡查找树的使用极大提高了查找效率。关于红黑树的声明和定义在ngx_rbtree.h和ngx_rbtree.c中。 关于查找方式一般我们会给出两种数据结构：hash表和二叉平衡查找树。 （1）hash的代表产品是r
【nginx源码学习与运用 六】红黑树结构ngx_rbtree_t
图像、视频、算法、Linux
12-12 1566
【nginx源码学习与运用】系列博客中的示例代码在csdn的代码托管服务器CODE上，地址https://code.csdn.net/u012819339/nginx_study ，你可以将其自由的下载到本地，或者通过Git来实时获取更新红黑树的原理就不在赘述了，这里着重给个例子，说明一下怎么运用nginx中的这个结构。相关结构struct ngx_rbtree_node_s { ngx_r
菜鸟nginx源码剖析数据结构篇（一）动态数组ngx_array_t
热门推荐
@Echo· 个人技术笔记
10-21 6万+
菜鸟nginx源码剖析数据结构篇（四）红黑树ngx_rbtree_t   Author：Echo Chen（陈斌） Email：chenb19870707@gmail.com Blog：Blog.csdn.net/chen19870707 Date：October 27h, 2014     1.ngx_rbtree优势和特点  
nginx：单独抽取nginx的红黑树源码以及运行例子
zy825316的专栏
04-25 861
缘由 最近一段时间想了想红黑树，理解了一下原理之内的，算法导论上已经讲的非常好了，我就不多废话了，所以这是我从nginx中抽取的红黑树的源码，共三分文件，能够单独运行。除了nginx中用于写的红黑树的两份代码以外，主要是就运行实例的main函数文件。 红黑树的好处 两附图说清楚，如果我们有序插入1、6、8、11、13、15、17、22、25、27普通二叉查找树的话，会形成下图一样的树：
6.Nginx红黑树rbtree
疯哥哥带你飞
10-24 832
Nginx的定时器管理借助红黑树来完成，红黑树这种数据结构在很多开源项目中被广泛使用。 红黑树是一种自平衡二叉搜索树，可以在O(log n)时间内做查找、插入和删除，这里n是树中元素的数目。 红黑树是每个节点都带有颜色属性的二叉搜索数，颜色为红色或黑色。在二叉搜索树的一般要求以外，它还有以下的额外要求： （1）节点是红色或黑色 （2）根节点是黑色的 （3）所有叶子都是黑色（叶子是
nginx学习笔记(5)：高级数据结构ngx_rbtree_t
li27z的博客
03-12 980
nginx高级数据结构ngx_rbtree_t
ngx-treeview：带有复选框的Angular treeview组件
01-31
ngx-treeview 带有复选框的Angular Treeview组件 依存关系 该组件当前支持Bootstrap4。如果您正在使用Bootstrap 4 alpha 6，请降级到较早的版本1.0.10。 您可以自己定制CSS，以分解对Bootstrap的依赖性。 产品特点 无限树级 状态：已禁用/崩溃，展开 筛选 国际化（i18n）支持 模板 三态复选框 演示版 安装 安装以上依赖项后，请通过以下方式安装ngx-treeview ： npm install ngx-treeview --save 安装完成后，您需要在应用程序模块中导入我们的主模块： import { TreeviewModule } from 'ngx-treeview' ; @ NgModule ( { declarations : [ AppComponent , ... ] , imports : [ TreeviewModule . forRoot ( ) , ... ] , bootstrap : [ AppComponent ] } ) export class AppModu
nginx--rbtree使用详解
jiuniangyuanzikk的专栏
11-10 2202
红黑数的性质这里就不多说了网上很多，主要看看nginx是如何定义的rbtree和怎么使用它       rbtree = ngx_slab_alloc(shpool, sizeof(ngx_rbtree_t)); //从共享内存中创建一颗红黑树 sentinel = ngx_slab_alloc(shpool, sizeof(ngx_rbtree_node_t)); //创建了一个红黑
ngx_rbtree的基本使用方法
magic的博客
08-06 1920
ngx_rbtree 导语： 红黑树是一个常用的高级数据结构，它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的:它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目. 一： 红黑树的性质 1. 每个节点不是红的就是黑的 （必须上色嘛） 2. 根节点必须是黑的 3. 每个叶节点是黑色的（ngx 是sentinel） 4. 如果该节点是
NGINX下的红黑树源码详解（附 流程图和GIF）
dearQiHao的博客
11-03 4021
      之前博主稍微讲解了下红黑树的原理,那么在这篇博客博主想要把红黑树讲的更加的透彻,以便于更多的人了解红黑树 （本博客会更加详细的介绍之前的博客没介绍到的，所以各位看官不同再回去翻看博主之前那篇红黑树的原理讲解了。）       博主之前也看过很多对红黑树的介绍但是博主感...
nginx源码学习2——扒、封装红黑树代码
liu3daniel的博客
06-23 318
说明： 1.nginx红黑树除了是个通用结构体，还是定时器实现的载体，进一步学习定时器代码需要了解红黑树用法； 2.nginx红黑树基本上只提供了一个初始化红黑树、增、删节点，查找最小节点四种操作，其实对nginx也够了； 3.nginx红黑树细节暴露比较多，节点要自己malloc自己构造，插入操作的第一步（旋转前）要自己实现（尽管各种实现的不同处都只是在key相同时提供比较大小的方法），节
Angular使用ngx-treeview实现异步加载多选选择树
shiyc12的博客
02-18 997
最近遇到个问题，ngx-treeview这个控件不支持原生的异步数据加载，也没有点击展开时的“onExpandCollapse”事件，导致只能一次性地把全部数据加载进去，很慢。我并非前端开发人员，对typescript、angular这些都不太熟悉，所以花了两天时间才解决，以此记录。 ngx-treeview官方文档：ngx-treeview - npm (npmjs.com) 以及小例子：ngx-treeview (leovo2708.github.io) 我的方法： 自定义ng-template
NGINX研究
happylzs2008的专栏
05-04 184
nginx源码分析—内存池结构ngx_pool_t及内存管理 https://www.cnblogs.com/405845829qq/p/4379093.html nginx的数据结构(1)——ngx_int_t与ngx_rbtree_t https://blog.csdn.net/bipedal_bit/article/details/47306809 Linux下Sublime的...
Angular 组件升级实战：将项目中的ng2-tree组件替换成ngx-tree
Ahua_Core的博客
07-14 891
Angular 树形组件ng2-tree与ngx-treeview需求描述初识ng2-tree初识ngx-treeview改造之路 ①（坑）修改样式限制一开始都是不选中把checkbox改成radio？爬出坑 前阵子我做了一个比较好玩同时又是比较大坑的task。在这个过程中，踩了许多坑，走了一些奇奇怪怪崎岖的弯路hhhh。 不过实践下来终归是有趣好玩的，不仅学到了一些骚操作（尽管最后不一定采用，但确实是个好的思路），也加深了对这两个组件特性的理解。故对此过程做简单记录。 需求描述 需求：把项目中的ng2-t
红黑树实现定时器
最新发布
向往天空的鱼
11-16 1027
借助nginx中红黑树源码实现一个简单定时器demo
详解Nginx ngx_pool_s结构：内存池与网络模型
本文主要探讨了Nginx的内部实现原理，特别是围绕ngx_pool_s结构进行深入解析。Nginx采用高效的事件驱动架构，其中核心的概念包括Reactor模型，它是一种常见的处理并发I/O的模式，通过多路复用器（如Linux上的select...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值