C++博客-那谁的技术博客-随笔分类-算法与数据结构

ccache发布0.5版本

那谁 — Fri, 14 Nov 2008 08:54:00 GMT

摘要: 阅读全文

那谁 2008-11-14 16:54 发表评论

红黑树的实现源码(第二次修订版)

那谁 — Mon, 10 Nov 2008 09:50:00 GMT

我曾经写过两个两个红黑树的实现, 分别在:
http://www.cppblog.com/converse/archive/2006/10/07/13413.html
http://www.cppblog.com/converse/archive/2007/11/28/37430.html

最近因为要给ccache加入红黑树的支持, 找出来曾经实现的代码作为参考, 这才发现原来的实现都是有问题的,也怪我的测试用例写的不好, 仅仅对插入操作进行了测试, 我向所有因为阅读了这份代码而造成困惑的朋友表示道歉.

这次重新实现, 所有的代码推倒重新编写, 参考了linux内核中红黑树的实现算法, 并且对测试用例进行了加强,希望这是最后一个对红黑树算法的修订版本.

/*-----------------------------------------------------------
    RB-Tree的插入和删除操作的实现算法
    参考资料:
    1) <>
    2) http://lxr.linux.no/linux/lib/rbtree.c

    作者：http://www.cppblog.com/converse/
    您可以自由的传播，修改这份代码，转载处请注明原作者

    红黑树的几个性质:
    1) 每个结点只有红和黑两种颜色
    2) 根结点是黑色的
    3)空节点是黑色的（红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点）。
    4) 如果一个结点是红色的,那么它的左右两个子结点的颜色是黑色的
    5) 对于每个结点而言,从这个结点到叶子结点的任何路径上的黑色结点
    的数目相同
-------------------------------------------------------------*/

#include
#include
#include

typedef int key_t;
typedef int data_t;

typedef enum color_t
{
    RED = 0,
    BLACK = 1
}color_t;

typedef struct rb_node_t
{
    struct rb_node_t *left, *right, *parent;
    key_t key;
    data_t data;
    color_t color;
}rb_node_t;

/* forward declaration */
rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root);
rb_node_t* rb_search(key_t key, rb_node_t* root);
rb_node_t* rb_erase(key_t key, rb_node_t* root);

int main()
{
    int i, count = 900000;
    key_t key;
    rb_node_t* root = NULL, *node = NULL;

    srand(time(NULL));
    for (i = 1; i < count; ++i)
    {
        key = rand() % count;
        if ((root = rb_insert(key, i, root)))
        {
            printf("[i = %d] insert key %d success!\n", i, key);
        }
        else
        {
            printf("[i = %d] insert key %d error!\n", i, key);
            exit(-1);
        }

        if ((node = rb_search(key, root)))
        {
            printf("[i = %d] search key %d success!\n", i, key);
        }
        else
        {
            printf("[i = %d] search key %d error!\n", i, key);
            exit(-1);
        }
        if (!(i % 10))
        {
            if ((root = rb_erase(key, root)))
            {
                printf("[i = %d] erase key %d success\n", i, key);
            }
            else
            {
                printf("[i = %d] erase key %d error\n", i, key);
            }
        }
    }

    return 0;
}

static rb_node_t* rb_new_node(key_t key, data_t data)
{
    rb_node_t *node = (rb_node_t*)malloc(sizeof(struct rb_node_t));

    if (!node)
    {
        printf("malloc error!\n");
        exit(-1);
    }
    node->key = key, node->data = data;

    return node;
}

/*-----------------------------------------------------------
|   node           right
|   / \    ==>     / \
|   a right     node y
|       / \           / \
|       b y         a   b
-----------------------------------------------------------*/
static rb_node_t* rb_rotate_left(rb_node_t* node, rb_node_t* root)
{
    rb_node_t* right = node->right;

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

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

    return root;
}

/*-----------------------------------------------------------
|       node           left
|       / \            / \
|    left y   ==>    a   node
|   / \               / \
| a   b             b   y
-----------------------------------------------------------*/
static rb_node_t* rb_rotate_right(rb_node_t* node, rb_node_t* root)
{
    rb_node_t* left = node->left;

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

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

    return root;
}

static rb_node_t* rb_insert_rebalance(rb_node_t *node, rb_node_t *root)
{
    rb_node_t *parent, *gparent, *uncle, *tmp;

    while ((parent = node->parent) && parent->color == RED)
    {
        gparent = parent->parent;

        if (parent == gparent->left)
        {
            uncle = gparent->right;
            if (uncle && uncle->color == RED)
            {
                uncle->color = BLACK;
                parent->color = BLACK;
                gparent->color = RED;
                node = gparent;
            }
            else
            {
                if (parent->right == node)
                {
                    root = rb_rotate_left(parent, root);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                parent->color = BLACK;
                gparent->color = RED;
                root = rb_rotate_right(gparent, root);
            }
        }
        else
        {
            uncle = gparent->left;
            if (uncle && uncle->color == RED)
            {
                uncle->color = BLACK;
                parent->color = BLACK;
                gparent->color = RED;
                node = gparent;
            }
            else
            {
                if (parent->left == node)
                {
                    root = rb_rotate_right(parent, root);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                parent->color = BLACK;
                gparent->color = RED;
                root = rb_rotate_left(gparent, root);
            }
        }
    }

    root->color = BLACK;

    return root;
}

static rb_node_t* rb_erase_rebalance(rb_node_t *node, rb_node_t *parent, rb_node_t *root)
{
    rb_node_t *other, *o_left, *o_right;

    while ((!node || node->color == BLACK) && node != root)
    {
        if (parent->left == node)
        {
            other = parent->right;
            if (other->color == RED)
            {
                other->color = BLACK;
                parent->color = RED;
                root = rb_rotate_left(parent, root);
                other = parent->right;
            }
            if ((!other->left || other->left->color == BLACK) &&
                (!other->right || other->right->color == BLACK))
            {
                other->color = RED;
                node = parent;
                parent = node->parent;
            }
            else
            {
                if (!other->right || other->right->color == BLACK)
                {
                    if ((o_left = other->left))
                    {
                        o_left->color = BLACK;
                    }
                    other->color = RED;
                    root = rb_rotate_right(other, root);
                    other = parent->right;
                }
                other->color = parent->color;
                parent->color = BLACK;
                if (other->right)
                {
                    other->right->color = BLACK;
                }
                root = rb_rotate_left(parent, root);
                node = root;
                break;
            }
        }
        else
        {
            other = parent->left;
            if (other->color == RED)
            {
                other->color = BLACK;
                parent->color = RED;
                root = rb_rotate_right(parent, root);
                other = parent->left;
            }
            if ((!other->left || other->left->color == BLACK) &&
                (!other->right || other->right->color == BLACK))
            {
                other->color = RED;
                node = parent;
                parent = node->parent;
            }
            else
            {
                if (!other->left || other->left->color == BLACK)
                {
                    if ((o_right = other->right))
                    {
                        o_right->color = BLACK;
                    }
                    other->color = RED;
                    root = rb_rotate_left(other, root);
                    other = parent->left;
                }
                other->color = parent->color;
                parent->color = BLACK;
                if (other->left)
                {
                    other->left->color = BLACK;
                }
                root = rb_rotate_right(parent, root);
                node = root;
                break;
            }
        }
    }

    if (node)
    {
        node->color = BLACK;
    }

    return root;
}

static rb_node_t* rb_search_auxiliary(key_t key, rb_node_t* root, rb_node_t** save)
{
    rb_node_t *node = root, *parent = NULL;
    int ret;

    while (node)
    {
        parent = node;
        ret = node->key - key;
        if (0 < ret)
        {
            node = node->left;
        }
        else if (0 > ret)
        {
            node = node->right;
        }
        else
        {
            return node;
        }
    }

    if (save)
    {
        *save = parent;
    }

    return NULL;
}

rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)
{
    rb_node_t *parent = NULL, *node;

    parent = NULL;
    if ((node = rb_search_auxiliary(key, root, &parent)))
    {
        return root;
    }

    node = rb_new_node(key, data);
    node->parent = parent;
    node->left = node->right = NULL;
    node->color = RED;

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

    return rb_insert_rebalance(node, root);
}

rb_node_t* rb_search(key_t key, rb_node_t* root)
{
    return rb_search_auxiliary(key, root, NULL);
}

rb_node_t* rb_erase(key_t key, rb_node_t *root)
{
    rb_node_t *child, *parent, *old, *left, *node;
    color_t color;

    if (!(node = rb_search_auxiliary(key, root, NULL)))
    {
        printf("key %d is not exist!\n");
        return root;
    }

    old = node;

    if (node->left && node->right)
    {
        node = node->right;
        while ((left = node->left) != NULL)
        {
            node = left;
        }
        child = node->right;
        parent = node->parent;
        color = node->color;

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

        if (node->parent == old)
        {
            parent = node;
        }

        node->parent = old->parent;
        node->color = old->color;
        node->right = old->right;
        node->left = old->left;

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

        old->left->parent = node;
        if (old->right)
        {
            old->right->parent = node;
        }
    }
    else
    {
        if (!node->left)
        {
            child = node->right;
        }
        else if (!node->right)
        {
            child = node->left;
        }
        parent = node->parent;
        color = node->color;

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

    free(old);

    if (color == BLACK)
    {
        root = rb_erase_rebalance(child, parent, root);
    }

    return root;
}

那谁 2008-11-10 17:50 发表评论

ccache发布0.4版本

那谁 — Fri, 31 Oct 2008 15:59:00 GMT

摘要: 阅读全文

那谁 2008-10-31 23:59 发表评论

(算法导论习题解exercise2.3-4)递归版插入排序

那谁 — Mon, 29 Sep 2008 15:27:00 GMT

摘要: 阅读全文

那谁 2008-09-29 23:27 发表评论

(算法导论习题解problem2.4)寻找一个序列中逆序对的数量

那谁 — Mon, 29 Sep 2008 12:32:00 GMT

摘要: 阅读全文

那谁 2008-09-29 20:32 发表评论

(算法导论习题解exercise2.3-7)给定一个整数序列以及一个数X,确定该序列中是否有两个数的和为X

那谁 — Mon, 29 Sep 2008 02:40:00 GMT

摘要: 阅读全文

那谁 2008-09-29 10:40 发表评论

原地归并算法

那谁 — Sun, 28 Sep 2008 11:51:00 GMT

摘要: 阅读全文

那谁 2008-09-28 19:51 发表评论

AVL树删除节点算法

那谁 — Wed, 17 Sep 2008 04:38:00 GMT

摘要: 阅读全文

那谁 2008-09-17 12:38 发表评论

AVL树中单,双旋转的解释

那谁 — Sun, 07 Sep 2008 16:23:00 GMT

摘要: 阅读全文

那谁 2008-09-08 00:23 发表评论

前缀匹配问题与trie树

那谁 — Tue, 19 Aug 2008 15:41:00 GMT

摘要: 阅读全文

那谁 2008-08-19 23:41 发表评论

服务器公共库开发-内存池管理模块

那谁 — Mon, 11 Aug 2008 15:30:00 GMT

摘要: 阅读全文

那谁 2008-08-11 23:30 发表评论

ccache发布0.3版本

那谁 — Thu, 07 Aug 2008 09:27:00 GMT

摘要: 阅读全文

那谁 2008-08-07 17:27 发表评论

如何使用位操作得到大于N且为2的次方的最小的数

那谁 — Sat, 21 Jun 2008 07:36:00 GMT

摘要: 如何使用位操作得到大于N且为2的次方的最小的数阅读全文

那谁 2008-06-21 15:36 发表评论

ccache发布0.2版本

那谁 — Wed, 02 Apr 2008 04:00:00 GMT

摘要: ccache发布0.2版本阅读全文

那谁 2008-04-02 12:00 发表评论

研究了一下SGI STL的内存算法

那谁 — Tue, 01 Apr 2008 11:55:00 GMT

摘要: 仿SGI STL的内存池算法.
阅读全文

那谁 2008-04-01 19:55 发表评论

memcache内存池的设计原理

那谁 — Mon, 21 Jan 2008 15:34:00 GMT

memcache中管理内存的数据结构如下:

typedef struct {
    unsigned int size;      /* sizes of items */
    unsigned int perslab;   /* how many items per slab */

    void **slots;           /* list of item ptrs */
    unsigned int sl_total;  /* size of previous array */
    unsigned int sl_curr;   /* first free slot */

    void *end_page_ptr;         /* pointer to next free item at end of page, or 0 */
    unsigned int end_page_free; /* number of items remaining at end of last alloced page */

    unsigned int slabs;     /* how many slabs were allocated for this class */

    void **slab_list;       /* array of slab pointers */
    unsigned int list_size; /* size of prev array */

    unsigned int killing;  /* index+1 of dying slab, or zero if none */
} slabclass_t;

程序中有一个全局的数组
static slabclass_t slabclass[POWER_LARGEST + 1]用于保存slab,预分配内存池时调用的是void slabs_init(const size_t limit, const double factor) 函数,其中limit是内存池的最大容量,factor是分配时的增长因子.
比方说,加入factor是2,第一个在slabclass数组中的slab的每个item大小是128字节,那么下一个slab每个item的大小就是128*2,再下一个就是128*2*2(注意,为了简化问题的说明,上面没有考虑地址对齐的因素).

在预分配内存池时,最多给每个slab保存item的容量是1M内存,这个数值由#define POWER_BLOCK 1048576决定.
因此,slab中的几个元素在预分配内存时是这么定的:
size有一个起始值,这个值以后的增长由factor决定,增长的过程前面已经阐述过了;
perslab保存的是一个slab存放的item数量,因此perslab = POWER_BLOCK / slabclass[i].size;
如果预先分配一段内存供使用的话,也就是没有定义DONT_PREALLOC_SLABS宏,那么就调用slabs_preallocate进行预分配内存.
其中,end_page_ptr指向这个预分配好的指针,end_page_free表示的是目前空闲可用item的数量,在预分配时,这个值与perslab相同.
在这个内存池模型中,每个page实际上是一个数组,数组中每个元素的大小就是这个slab中item的大小.

另外,slots保存的是释放出来的item指针,sl_total表示总的数量,sl_curr表示的是目前可用的已经释放出来的item数量.

每一次要分配内存的时候,首先根据需要分配的内存大小在slabclass数组中查找索引最小的一个大于所要求内存的slab,如果slots不为空,那么就从这里返回内存,否则去查找end_page_ptr,如果也没有,那么就只能返回NULL了.
每一次释放内存的时候,同样的找到应该返回内存的slab元素,改写前面提到的slot指针和sl_curr数.

有点仓促,以后再完善~~

那谁 2008-01-21 23:34 发表评论

[算法]红黑树的实现代码(修订版)

那谁 — Wed, 28 Nov 2007 06:29:00 GMT

摘要: [算法]红黑树的实现代码(修订版) 阅读全文

那谁 2007-11-28 14:29 发表评论

[算法]找出m个数中最小的n个数

那谁 — Mon, 26 Nov 2007 10:54:00 GMT

摘要: 找出n个数中最大的m个数。阅读全文

那谁 2007-11-26 18:54 发表评论

AVL树的实现代码

那谁 — Wed, 29 Aug 2007 14:06:00 GMT

摘要: AVL树的实现代码阅读全文

那谁 2007-08-29 22:06 发表评论

仿STL中的堆算法的一个实现

那谁 — Mon, 19 Mar 2007 16:28:00 GMT

摘要: 仿STL中的堆算法的一个实现阅读全文

那谁 2007-03-20 00:28 发表评论

[数据结构]红黑树的实现源码

那谁 — Sat, 07 Oct 2006 06:32:00 GMT

摘要: 半年之前写的一个红黑树的实现算法了,当时有点忙没有写相应的文档,一下子几乎全都忘记了,作一个记录,改天有空了来补充说明文档. 阅读全文

那谁 2006-10-07 14:32 发表评论

[算法问题]合并两个已经排序的数组为另一个数组

那谁 — Tue, 26 Sep 2006 15:27:00 GMT

摘要: 设子数组a[0:k]和a[k+1:n-1]已排好序（0<=k<=n-1).试设计一个合并这两个子数组为排好序的数组a[0:n-1]的算法．要求算法在最坏的情况下所用的计算时间为O(n), 且只用到O(1)的辅助空间．阅读全文

那谁 2006-09-26 23:27 发表评论

[算法问题]交换两个子数组的元素值

那谁 — Tue, 26 Sep 2006 15:21:00 GMT

摘要: 设a[0:n-1]是一个有n个元素的数组，k(0<=k<=n-1)是一个非负整数．试设计一个算法将子数组a[0:k]与a[k+1:n-1]换位．要求算法在最坏情况下耗时O(n), 且只用到O(1)的辅助空间．阅读全文

那谁 2006-09-26 23:21 发表评论

二叉查找树的解析与实现

那谁 — Fri, 28 Jul 2006 16:33:00 GMT

摘要: 二叉查找树的解析与实现阅读全文

那谁 2006-07-29 00:33 发表评论

[算法问题]判断一个数是不是2的幂?

那谁 — Mon, 10 Jul 2006 15:25:00 GMT

摘要: [算法问题]判断一个数是不是2的幂? 阅读全文

那谁 2006-07-10 23:25 发表评论

递归和递推的非严格概念解释

那谁 — Sun, 09 Jul 2006 13:43:00 GMT

摘要: 时常看到这两个词,有时分不清区别,想了一想,写了这篇非严格的概念分析阅读全文

那谁 2006-07-09 21:43 发表评论

二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)

那谁 — Sat, 08 Jul 2006 07:21:00 GMT

摘要: 费了两天时间写的,包括前中后序遍历的递归和非递归算法,还有层序遍历总共2*3 + 1 = 7中遍历二叉树的算法,感觉其中后序遍历的非递归算法比较困难,想了很久最后的实现还是不够优雅,请大家指正~~总共三个文件,一个头文件,一个对应的cpp文件,还有一个用于测试的文件.头文件:/**//*********************************************************... 阅读全文

那谁 2006-07-08 15:21 发表评论

[算法问题]寻找一个序列中第n大的元素

那谁 — Fri, 07 Jul 2006 18:04:00 GMT

摘要: 问题描述:给定一个序列,以及指定这个序列的一个范围,寻找这个范围之内第n大的元素,如果n大于这个范围之内的元素数量那么就返回-1.这是快速排序算法中partiton算法的一个应用,不断的分割序列,如果分割的位置正好是要找的位置,那么返回结果,否则视情况在前半部分和后半部分继续查找,当然这个时候n值也要相应的变化了~~ /**/ /... 阅读全文

那谁 2006-07-08 02:04 发表评论

KMP算法的实现

那谁 — Wed, 05 Jul 2006 09:44:00 GMT

摘要: KMP算法是一种用于字符串匹配的算法,这个算法的高效之处在于当在某个位置匹配不成功的时候可以根据之前的匹配结果从模式字符串的另一个位置开始,而不必从头开始匹配字符串.因此这个算法的关键在于,当某个位置的匹配不成功的时候,应该从模式字符串的哪一个位置开始新的比较.假设这个值存放在一个next数组中,其中next数组中的元素满足这个条件:next[j] = k,表示的是当模式字符串中的第j + 1个(... 阅读全文

那谁 2006-07-05 17:44 发表评论

常见排序算法的实现(六)-归并排序

那谁 — Mon, 03 Jul 2006 17:34:00 GMT

归并排序的算法思想:把待排序序列分成相同大小的两个部分,依次对这两部分进行归并排序,完毕之后再按照顺序进行合并.

// 归并排序中的合并算法
void Merge(int array[], int start, int mid, int end)
{
    int temp1[10], temp2[10];
    int n1, n2;
    n1 = mid - start + 1;
    n2 = end - mid;

    // 拷贝前半部分数组
    for (int i = 0; i < n1; i++)
    {
        temp1[i] = array[start + i];
    }
    // 拷贝后半部分数组
    for (int i = 0; i < n2; i++)
    {
        temp2[i] = array[mid + i + 1];
    }
    // 把后面的元素设置的很大
    temp1[n1] = temp2[n2] = 1000;
    // 逐个扫描两部分数组然后放到相应的位置去
    for (int k = start, i = 0, j = 0; k <= end; k++)
    {
        if (temp1[i] <= temp2[j])
        {
            array[k] = temp1[i];
            i++;
        }
        else
        {
            array[k] = temp2[j];
            j++;
        }
    }
}

// 归并排序
void MergeSort(int array[], int start, int end)
{
    if (start < end)
    {
        int i;
        i = (end + start) / 2;
        // 对前半部分进行排序
        MergeSort(array, start, i);
        // 对后半部分进行排序
        MergeSort(array, i + 1, end);
        // 合并前后两部分
        Merge(array, start, i, end);
    }
}

那谁 2006-07-04 01:34 发表评论