10.nginx源码分析之数据结构：ngx__rbtree_t

nginx源码分析之数据结构：ngx__rbtree_t

除了之前介绍的list、array、queue等线性数据结构之外，nginx还提供了查询效率较高的红黑树结构，这种二叉平衡查找树的使用极大提高了查找效率。关于红黑树的声明和定义在ngx_rbtree.h和ngx_rbtree.c中。

关于查找方式一般我们会给出两种数据结构：hash表和二叉平衡查找树。

（1）hash的代表产品是redis和memcached等内存数据库，可以在极短的时间内完成查找动作；
（2）二叉平衡查找树的代表是红黑树，在linux内核的进程调度中经常使用；

然而两者都有着不同的优缺点：

（1）hash表的查找效率很高（基本是O(1)的时间复杂度），但是需要消耗大量的内存；

（2）二叉平衡查找树的速度也比较快（基本取决于树的高度，因为近似平衡，所以左右子树的高度差很小），但是在删除和添加的节点的时候需要调整树的结构。

红黑树的性质：

（1）节点是红色或者黑色；
（2）根节点是黑色；
（3）所有叶子节点都是黑色（哨兵）；
（4）每个红色节点的两个子接单都是黑色（不会出现两个都是红色的父子节点）；
（5）从任意一个节点到叶子节点的路径中的黑色节点数量是相同的。

ngx_rbtree_t

在nginx中对于红黑树的结构体定义有以下两个：红黑树的节点和红黑树的控制信息。

红黑树的节点结构如下：

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 ngx_rbtree_node_s {
    ngx_rbtree_key_t       key;      //查询的关键字
    ngx_rbtree_node_t     *left;     //左孩子
    ngx_rbtree_node_t     *right;    //右孩子
    ngx_rbtree_node_t     *parent;   //父亲节点
    u_char                 color;    //颜色
    u_char                 data;     //数值（因为太小一般没有太多作用）
};

红黑树的控制信息结构：

typedef struct ngx_rbtree_s  ngx_rbtree_t;


//定义此函数指针是为了让客户自己设置插入方式
typedef void (*ngx_rbtree_insert_pt) (ngx_rbtree_node_t *root,
    ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

struct ngx_rbtree_s {
    ngx_rbtree_node_t      *root;      //根节点地址
    ngx_rbtree_node_t      *sentinel;  //哨兵
    ngx_rbtree_insert_pt   insert;     //插入节点的函数指针
};

在ngx_rbtree.h中还定义了宏定义还隐藏节点指针操作的细节：

//红黑树控制信息的初始化
#define ngx_rbtree_init(tree, s, i)                                           \
    ngx_rbtree_sentinel_init(s);                                              \
    (tree)->root = s;                                                         \
    (tree)->sentinel = s;                                                     \
    (tree)->insert = i

//常见操作的宏定义

#define ngx_rbt_red(node)               ((node)->color = 1)   //1代表红色
#define ngx_rbt_black(node)             ((node)->color = 0)   //0代表黑色
#define ngx_rbt_is_red(node)            ((node)->color)
#define ngx_rbt_is_black(node)          (!ngx_rbt_is_red(node))
#define ngx_rbt_copy_color(n1, n2)      (n1->color = n2->color)

//哨兵的颜色是黑色的（空节点）
#define ngx_rbtree_sentinel_init(node)  ngx_rbt_black(node)

该文件中还定义了红黑树的常见接口，包括插入和删除两类操作：

void ngx_rbtree_insert(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);
void ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);
void ngx_rbtree_insert_value(ngx_rbtree_node_t *root, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel);
void ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *root,
    ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

ngx_rbtree.c主要定义了上述接口的实现过程，在介绍这些接口之前需要对三个静态的函数进行解释：

（1）找到二叉查找树的最小值：

因为二叉树在创建的时候就是把值比当前小的节点放在左孩子部分，比当前节点大的放在右孩子部分，所以最小的孩子是最左边的孩子。

static ngx_inline ngx_rbtree_node_t *
ngx_rbtree_min(ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
{
    //从根节点开始，最左边的还是就是当前二叉树值最小的孩子
    while (node->left != sentinel) {
        node = node->left;
    }

    return node;
}

（2）左旋操作

如图所示，对于根节点15来说，当其右孩子和左孩子的高度差大于1时，需要进行左旋转操作（AVL树，红黑树的要求没有这么严格），从而达到平衡的效果（左右孩子的高度差小于等于1）。

下面是代码实现：

static ngx_inline void
ngx_rbtree_left_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
    ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  *temp;

    //其中temp是当前旋转节点的右孩子，因为当前节点的右孩子会取代其成为新的
    //“根”，所以旋转后，node的右孩子就是temp的左孩子
    temp = node->right;
    node->right = temp->left;

    //如果temp的左孩子非空，修改左孩子的父节点指向
    if (temp->left != sentinel) {
        temp->left->parent = node;
    }

    temp->parent = node->parent;

    //如果被旋转的节点是根节点，则修改根节点的指向
    if (node == *root) {
        *root = temp;

    } else if (node == node->parent->left) {
        node->parent->left = temp;

    } else {
        node->parent->right = temp;
    }

    //修改旋转节点及其右孩子的双亲指向
    temp->left = node;
    node->parent = temp;
}

（3）右旋操作

右旋和左旋的原理是一样，只不过是因为左孩子部分的高度大于右孩子。

代码如下：

static ngx_inline void
ngx_rbtree_right_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
    ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  *temp;

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

    //其中temp是当前旋转节点的左孩子，因为当前节点的左孩子会取代其成为新的
    //“根”，所以旋转后，node的左孩子就是temp的右孩子
    if (temp->right != sentinel) {
        temp->right->parent = node;
    }

    temp->parent = node->parent;

    if (node == *root) {
        *root = temp;

    //修改旋转节点node的双亲节点的左孩子或右孩子指向
    } else if (node == node->parent->right) {
        node->parent->right = temp;

    } else {
        node->parent->left = temp;
    }

    temp->right = node;
    node->parent = temp;
}

除了删除三个操作之外，还有插入和删除等操作：

void
ngx_rbtree_insert(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  **root, *temp, *sentinel;

    /* a binary tree insert */

    //获得根节点的地址
    root = (ngx_rbtree_node_t **) &tree->root;
    sentinel = tree->sentinel;

    //根节点是空节点，则node是根节点，直接插入，因为是根所以颜色是黑色
    if (*root == sentinel) {
        node->parent = NULL;
        node->left = sentinel;
        node->right = sentinel;
        ngx_rbt_black(node);
        *root = node;

        return;
    }

    //否则使用用户指定的插入方法进行插入
    tree->insert(*root, node, sentinel);

    /* re-balance tree */

    //插入完成后对整个二叉树进行平衡操作
    while (node != *root && ngx_rbt_is_red(node->parent)) {

        //如果插入节点的双亲是双亲的左孩子部分
        if (node->parent == node->parent->parent->left) {
            temp = node->parent->parent->right;

            if (ngx_rbt_is_red(temp)) {
                ngx_rbt_black(node->parent);
                ngx_rbt_black(temp);
                                ngx_rbt_red(node->parent->parent);
                node = node->parent->parent;

            } else {
                if (node == node->parent->right) {
                    node = node->parent;
                    ngx_rbtree_left_rotate(root, sentinel, node);
                }

                ngx_rbt_black(node->parent);
                ngx_rbt_red(node->parent->parent);
                ngx_rbtree_right_rotate(root, sentinel, node->parent->parent);
            }

        } else {
            temp = node->parent->parent->left;

            if (ngx_rbt_is_red(temp)) {
                ngx_rbt_black(node->parent);
                ngx_rbt_black(temp);
                ngx_rbt_red(node->parent->parent);
                node = node->parent->parent;

            } else {
                if (node == node->parent->left) {
                    node = node->parent;
                    ngx_rbtree_right_rotate(root, sentinel, node);
                }

                ngx_rbt_black(node->parent);
                ngx_rbt_red(node->parent->parent);
                ngx_rbtree_left_rotate(root, sentinel, node->parent->parent);
            }
        }
    }

    ngx_rbt_black(*root);
}

下面列举了rbtree指定的两种类型的插入方法，一个是针对时间或者时间差、另外一个是针对字符串：

//针对字符串
void
ngx_rbtree_insert_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel)
{
    ngx_rbtree_node_t  **p;

    for ( ;; ) {

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

        //找到插入的位置，p为temp的左孩子或者右孩子
        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    //将node插入到该位置
    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    ngx_rbt_red(node);
}

//针对时间或者时间段
void ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel)
{
    ngx_rbtree_node_t  **p;

    for ( ;; ) {

        /* * Timer values * 1) are spread in small range, usually several minutes, * 2) and overflow each 49 days, if milliseconds are stored in 32 bits. * The comparison takes into account that overflow. */

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

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

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    ngx_rbt_red(node);
}

还有删除节点操作，该操作主要设置删除后的4中状态处理，红黑树的插入和删除操作可以参照july的博客进行理解：
http://blog.csdn.net/v_JULY_v/article/details/6105630

//红黑树删除节点操作
void
ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
{
    ngx_uint_t           red;
    ngx_rbtree_node_t  **root, *sentinel, *subst, *temp, *w;

    /* a binary tree delete */

    root = (ngx_rbtree_node_t **) &tree->root;
    sentinel = tree->sentinel;

    //被删除节点的左孩子为空
    if (node->left == sentinel) {
        temp = node->right;
        subst = node;

    //被删除节点的右孩子为空
    } else if (node->right == sentinel) {
        temp = node->left;
        subst = node;

    } else {   //被删除孩子的左右孩子都不为空
        subst = ngx_rbtree_min(node->right, sentinel);

        if (subst->left != sentinel) {
            temp = subst->left;
        } else {
            temp = subst->right;
        }
    }

    if (subst == *root) {
        *root = temp;
        ngx_rbt_black(temp);

        /* DEBUG stuff */
        node->left = NULL;
        node->right = NULL;
        node->parent = NULL;
        node->key = 0;

        return;
    }

    red = ngx_rbt_is_red(subst);

    if (subst == subst->parent->left) {
        subst->parent->left = temp;

    } else {
        subst->parent->right = temp;
    }

    if (subst == node) {

        temp->parent = subst->parent;

    } else {

        if (subst->parent == node) {
            temp->parent = subst;

        } else {
            temp->parent = subst->parent;
        }

        subst->left = node->left;
        subst->right = node->right;
        subst->parent = node->parent;
        ngx_rbt_copy_color(subst, node);

        if (node == *root) {
            *root = subst;

        } else {
            if (node == node->parent->left) {
                node->parent->left = subst;
            } else {
                node->parent->right = subst;
            }
        }

        if (subst->left != sentinel) {
            subst->left->parent = subst;
        }

        if (subst->right != sentinel) {
            subst->right->parent = subst;
        }
    }

    /* DEBUG stuff */
    node->left = NULL;
    node->right = NULL;
    node->parent = NULL;
    node->key = 0;


    if (red) {
        return;
    }

    /* a delete fixup */

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

        if (temp == temp->parent->left) {
            w = temp->parent->right;

            if (ngx_rbt_is_red(w)) {
                ngx_rbt_black(w);
                ngx_rbt_red(temp->parent);
                ngx_rbtree_left_rotate(root, sentinel, temp->parent);
                w = temp->parent->right;
            }

            if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
                ngx_rbt_red(w);
                temp = temp->parent;

            } else {
                if (ngx_rbt_is_black(w->right)) {
                    ngx_rbt_black(w->left);
                    ngx_rbt_red(w);
                    ngx_rbtree_right_rotate(root, sentinel, w);
                    w = temp->parent->right;
                }

                ngx_rbt_copy_color(w, temp->parent);
                ngx_rbt_black(temp->parent);
                ngx_rbt_black(w->right);
                ngx_rbtree_left_rotate(root, sentinel, temp->parent);
                temp = *root;
            }

        } else {
            w = temp->parent->left;

            if (ngx_rbt_is_red(w)) {
                ngx_rbt_black(w);
                ngx_rbt_red(temp->parent);
                ngx_rbtree_right_rotate(root, sentinel, temp->parent);
                w = temp->parent->left;
            }
             if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
                ngx_rbt_red(w);
                temp = temp->parent;

            } else {
                if (ngx_rbt_is_black(w->left)) {
                    ngx_rbt_black(w->right);
                    ngx_rbt_red(w);
                    ngx_rbtree_left_rotate(root, sentinel, w);
                    w = temp->parent->left;
                }

                ngx_rbt_copy_color(w, temp->parent);
                ngx_rbt_black(temp->parent);
                ngx_rbt_black(w->left);
                ngx_rbtree_right_rotate(root, sentinel, temp->parent);
                temp = *root;
            }
        }
    }

    ngx_rbt_black(temp);
}