sourceforge源码下载:
https://sourceforge.net/project/showfiles.php?group_id=202044
红黑树插入与删除代码实现
简述:stl map的底层实现,rbtree关于红黑树的插入,侯杰的stl源码剖析已经做了很详细的说明,在此不赘述。这里主要讲一下红黑树的删除,并给出源码实例,代码在vs7上调通并测试正确算法说明:
/*
*
*从rb树中删除一个节点*
*删除除节点 z , 则可以用y完全取代z(位置,颜色,用户数据), 删除z演变成删除y*
* 图1
* a a
* / / / /
* ? z ? y
* / / ----> / /
* ? b ? b
* / / / /
* y ? del ---> z ?
* / /
* ?1 ?1
*
*
*如果z是红色 则?1对应的子树根节点直接挪到z对应的位置,即完成了删除工作,并保证了红黑树的平衡性
*如果z是黑色 并且?1对应的子树根节点x为红色,则把?1挪到z的位置,并把x改成黑色,即完成了删除工作,并保证了红黑树的平衡性
*如果z是黑色 并且?1对应的子树根节点x也为黑色。
*图2
*
* ?
* / /
* ? x_parent
* / /
* x ?2 = w
* / /
* ? ?
*图2即最终要面临的情况
*x这个分支,由于去除了一个黑色的结点,而x又是黑色,它比 ?2 那个分支相比,
"少了一个黑色的结点
"
*
*图3
* x_parent x_parent->parent
* / / / /
* x w --> x_parent w_new
* / / / / / /
* ? ? ?b?b ? ?
*假如?b ?b均为"黑" w也为黑 则把 w涂成红此时x分支与w分支"黑层数"相同 ,
*(x_parent有可能为红,但这不影响结果,因为在下一个循环中,x = x_parent,循环将退出,x即x_parent将被涂成黑,不违反红黑树规则)
*以x = x_parent比 w = w_new这个分支"少了一层" 持续向上迭代 (x = x_parent x_parent = x->parent) 至到根节点为至,即完成了删除工作,并保证了红黑树的平衡
*
*如果w为红,通过旋转,可以演化成图3的情况
*演化步骤如下:
*把w涂成黑色,x_parent涂成红色(根据红黑树定义x_parent必为黑色, w的左右子节点必为黑色)
*以x_parent为轴左旋
* w
* / /
* x_parent ?b
* / /
* x ?b = w_new(必为黑)
* / /
* ? ?
*x 分支比 ?b分支少了一层
*
* 即,不管w为红还是为黑,最终都可以演化成w为黑的情况
*
*w的子节点中有红色节点的情况
*这种情况可以考虑把w的红色节点转移到x分支,作为x分支的根节点,并涂成黑色,即完成了删除,并保证了红黑树的平衡
*具体变换如下 如果a不为红,可以经过旋转变换为红
*
* x_parent?
* / /
* x w黑
* / / / /
* ? ? 黑b 红a
*
* w?
* //
* x_parent黑 黑a
* //
* x 黑b
*即完成了删除,并保证了红黑树的平衡性
*
*/.h文件,接口说明 mymempool.h是一个内存池的接口,只提供内存分配功能,不影响算法的表述。==========================================================
myrbtree.h
/*
*
* myrbtree.h 红黑树
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#ifndef __MYRBTREE_H__
#define __MYRBTREE_H__
#include "mymempool.h"
/*
*
*1 表示 key1 比 key2 大
*0 表示 key1 比 key2 小
*
*/
typedef int (*myrbtree_compare)(const void * key1, const void * key2);
typedef struct __handle_myrbtree
{
int unused;
}handle_myrbtree;
typedef handle_myrbtree * HMYRBTREE;
typedef struct __handle_myrbtree_iter
{
int unused;
}handle_myrbtree_iter;
typedef handle_myrbtree_iter * HMYRBTREE_ITER;
/*
*
*创建rb树
*
*/
extern HMYRBTREE MyRBTreeConstruct(HMYMEMPOOL hm, myrbtree_compare compare);
/*
*
*销毁rb树
*
*/
extern void MyRBTreeDestruct(HMYRBTREE htree);
/*
*
*删除所有节点
*
*/
extern void MyRBTreeClear(HMYRBTREE htree);
/*
*
*往rb树中插入一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeInsertEqual(HMYRBTREE htree, const void * key, const void * userdata);
/*
*
*往rb树中插入一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeInsertUnique(HMYRBTREE htree, const void * key, const void * userdata);
/*
*
*从rb树中删除一个节点
*
*/
extern void MyRBTreeDelIter(HMYRBTREE htree, HMYRBTREE_ITER iter, void ** key, void ** data);
/*
*
*根据键值删除一个节点
*成功删除返回0, 否则返回-1
*
*/
extern int MyRBTreeDelKey(HMYRBTREE htree, const void * key, void ** key_ret, void ** data_ret);
/*
*
*获取节点的用户数据
*
*/
extern void * MyRBTreeGetIterData(const HMYRBTREE_ITER iter);
/*
*
*获取节点的键
*
*/
extern const void * MyRBTreeGetIterKey(const HMYRBTREE_ITER iter);
/*
*
*查找节点
*
*/
extern HMYRBTREE_ITER MyRBTreeSearch(const HMYRBTREE htree, const void * key);
/*
*
*计算最大层数
*
*/
extern int MyRBTreeLayer(const HMYRBTREE htree, int bmax);
/*
*
*"获取第一个节点"
*
*/
extern HMYRBTREE_ITER MyRBTreeBegin(const HMYRBTREE htree);
/*
*
*"获取最后一个节点"
*
*/
extern HMYRBTREE_ITER MyRBTreeEnd(const HMYRBTREE htree);
/*
*
*获取"下"一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeGetNext(const HMYRBTREE_ITER it);
/*
*
*获取"上"一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeGetPrev(const HMYRBTREE_ITER it);
/*
*
*检查红黑树是否合法
*
*/
extern int MyRBTreeExamin(const HMYRBTREE htree);
/*
*
*获取个数
*
*/
extern int MyRBTreeGetRealCount(const HMYRBTREE htree);
#endif
*
* myrbtree.h 红黑树
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#ifndef __MYRBTREE_H__
#define __MYRBTREE_H__
#include "mymempool.h"
/*
*
*1 表示 key1 比 key2 大
*0 表示 key1 比 key2 小
*
*/
typedef int (*myrbtree_compare)(const void * key1, const void * key2);
typedef struct __handle_myrbtree
{
int unused;
}handle_myrbtree;
typedef handle_myrbtree * HMYRBTREE;
typedef struct __handle_myrbtree_iter
{
int unused;
}handle_myrbtree_iter;
typedef handle_myrbtree_iter * HMYRBTREE_ITER;
/*
*
*创建rb树
*
*/
extern HMYRBTREE MyRBTreeConstruct(HMYMEMPOOL hm, myrbtree_compare compare);
/*
*
*销毁rb树
*
*/
extern void MyRBTreeDestruct(HMYRBTREE htree);
/*
*
*删除所有节点
*
*/
extern void MyRBTreeClear(HMYRBTREE htree);
/*
*
*往rb树中插入一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeInsertEqual(HMYRBTREE htree, const void * key, const void * userdata);
/*
*
*往rb树中插入一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeInsertUnique(HMYRBTREE htree, const void * key, const void * userdata);
/*
*
*从rb树中删除一个节点
*
*/
extern void MyRBTreeDelIter(HMYRBTREE htree, HMYRBTREE_ITER iter, void ** key, void ** data);
/*
*
*根据键值删除一个节点
*成功删除返回0, 否则返回-1
*
*/
extern int MyRBTreeDelKey(HMYRBTREE htree, const void * key, void ** key_ret, void ** data_ret);
/*
*
*获取节点的用户数据
*
*/
extern void * MyRBTreeGetIterData(const HMYRBTREE_ITER iter);
/*
*
*获取节点的键
*
*/
extern const void * MyRBTreeGetIterKey(const HMYRBTREE_ITER iter);
/*
*
*查找节点
*
*/
extern HMYRBTREE_ITER MyRBTreeSearch(const HMYRBTREE htree, const void * key);
/*
*
*计算最大层数
*
*/
extern int MyRBTreeLayer(const HMYRBTREE htree, int bmax);
/*
*
*"获取第一个节点"
*
*/
extern HMYRBTREE_ITER MyRBTreeBegin(const HMYRBTREE htree);
/*
*
*"获取最后一个节点"
*
*/
extern HMYRBTREE_ITER MyRBTreeEnd(const HMYRBTREE htree);
/*
*
*获取"下"一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeGetNext(const HMYRBTREE_ITER it);
/*
*
*获取"上"一个节点
*
*/
extern HMYRBTREE_ITER MyRBTreeGetPrev(const HMYRBTREE_ITER it);
/*
*
*检查红黑树是否合法
*
*/
extern int MyRBTreeExamin(const HMYRBTREE htree);
/*
*
*获取个数
*
*/
extern int MyRBTreeGetRealCount(const HMYRBTREE htree);
#endif
=============================================================
myrbtree.c
#include <stdlib.h>
#include <memory.h>
#include <assert.h>
#include "myutility.h"
#include "myrbtree.h"
typedef enum __rbtree_colour
{
rbtree_colour_black,
rbtree_colour_red,
}rbtree_colour;
typedef struct __myrbtree_node_t
{
struct __myrbtree_node_t * left;
struct __myrbtree_node_t * right;
struct __myrbtree_node_t * parent;
rbtree_colour colour;
void * key;
void * data;
}myrbtree_node_t;
typedef struct __myrbtree_t
{
myrbtree_node_t * root;
//内存池
HMYMEMPOOL hm;
//比较运算符
myrbtree_compare compare;
}myrbtree_t;
/*
*
*1 表示 key1 比 key2 大
*0 表示 key1 比 key2 小
*
*/
static __INLINE__ int rbtree_inter_compare(myrbtree_t * rbtree, const void * key1, const void * key2)
{
assert(rbtree && rbtree->compare);
return (*rbtree->compare)(key1, key2);
}
static __INLINE__ myrbtree_node_t * rbtree_inter_create_node(myrbtree_t * rbtree, const void * key, const void * data)
{
myrbtree_node_t * node_new = NULL;
assert(rbtree);
node_new = (myrbtree_node_t *)MyMemPoolMalloc(rbtree->hm, sizeof(*node_new));
if(NULL == node_new)
return NULL;
memset(node_new, 0, sizeof(*node_new));
node_new->key = (void *)key;
node_new->data = (void *)data;
return node_new;
}
static __INLINE__ void rbtree_inter_destroy_node(myrbtree_t * rbtree, myrbtree_node_t * node)
{
assert(rbtree && node);
MyMemPoolFree(rbtree->hm, node);
}
/*
*
*左旋
*
* A node
* / /
* / ----> /
* node A
*/
static __INLINE__ void rbtree_inter_rotate_left(/*myrbtree_t * rbtree*/myrbtree_node_t ** root, myrbtree_node_t * node)
{
myrbtree_node_t * A_node = NULL;
assert(root && node && node->parent);
A_node = node->parent;
node->parent = A_node->parent;
if(A_node->parent)
{
if(A_node == A_node->parent->left)
A_node->parent->left = node;
else
A_node->parent->right = node;
}
A_node->parent = node;
A_node->right = node->left;
if(node->left)
node->left->parent = A_node;
node->left = A_node;
if(A_node == *root)
*root = node;
assert(NULL == *root || NULL == (*root)->parent);
}
/*
*
*右旋
*
* A node
* / /
* / ---> /
* node A
*/
static __INLINE__ void rbtree_inter_rotate_right(/*myrbtree_t * rbtree*/myrbtree_node_t ** root, myrbtree_node_t * node)
{
myrbtree_node_t * A_node = NULL;
assert(root && node && node->parent);
A_node = node->parent;
node->parent = A_node->parent;
if(A_node->parent)
{
if(A_node == A_node->parent->left)
A_node->parent->left = node;
else
A_node->parent->right = node;
}
A_node->parent = node;
A_node->left = node->right;
if(node->right)
node->right->parent = A_node;
node->right = A_node;
if(A_node == *root)
*root = node;
assert(NULL == (*root) || NULL == (*root)->parent);
}
static __INLINE__ myrbtree_node_t * rbtree_inter_search(myrbtree_t * rbtree, myrbtree_node_t * root, const void * key)
{
myrbtree_node_t * y = NULL;/* 记录最后一个不大于key的节点 */
myrbtree_node_t * x = root;
assert(rbtree);
while(x)
{
if(!rbtree_inter_compare(rbtree, x->key, key))
y = x, x = x->right;
else
x = x->left;
}
return (NULL == y || rbtree_inter_compare(rbtree, key, y->key))?NULL:y;
}
static __INLINE__ myrbtree_node_t * rbtree_inter_searchex(myrbtree_t * rbtree, myrbtree_node_t * root, const void * key, myrbtree_node_t ** parent)
{
myrbtree_node_t * y = NULL;/* 记录最后一个不大于key的节点 */
myrbtree_node_t * x = root;
assert(rbtree && parent /*&& rbtree->root == root*/);
*parent = root;
while(x)
{
*parent = x;
if(!rbtree_inter_compare(rbtree, x->key, key))
y = x, x = x->right;
else
x = x->left;
}
return (NULL == y || rbtree_inter_compare(rbtree, key, y->key))?NULL:y;
}
static __INLINE__ int rbtree_inter_ismynode(const myrbtree_node_t * root, const myrbtree_node_t * node)
{
int ret = 0;
if(NULL == root)
return 0;
if(node == root)
return 1;
if(root->left)
ret = rbtree_inter_ismynode(root->left, node);
if(ret)
return ret;
if(root->right)
return rbtree_inter_ismynode(root->right, node);
return 0;
}
/*
*
*旋转红黑树,使之符合红黑树的规则
*rbtree:需要旋转的红黑树
*node:新加入的节点
*
*/
static __INLINE__ void rbtree_inter_rebalance(/*myrbtree_t * rbtree*/myrbtree_node_t ** root, myrbtree_node_t * node)
{
assert(root && node && node->parent);
//新加入节点必为红
node->colour = rbtree_colour_red;
//如果父节点为根节点,根据红黑树的定义根节点必为黑
if(node->parent == *root)
return;
//不为根结点,祖父节点必存在
assert(node->parent->parent);
//如果父节点不为黑
while(node != *root && rbtree_colour_red == node->parent->colour)
{
//如果父节点是祖父节点的左孩子
if(node->parent == node->parent->parent->left)
{
//如果伯父节点存在,且为红
if(node->parent->parent->right && rbtree_colour_red == node->parent->parent->right->colour)
{
//把父节点与伯父节点涂成黑色
node->parent->colour = rbtree_colour_black;
node->parent->parent->right->colour = rbtree_colour_black;
//把祖父结点涂成红色
node->parent->parent->colour = rbtree_colour_red;
//指针往上走
node = node->parent->parent;
}
else
{
//如果是外侧插入
if(node == node->parent->left)
{
//node为红
node->colour = rbtree_colour_red;
//父节点为黑
node->parent->colour = rbtree_colour_black;
//祖父节点为红
node->parent->parent->colour = rbtree_colour_red;
//父节点为轴右旋转
rbtree_inter_rotate_right(root, node->parent);
}
else
{
myrbtree_node_t * temp = node->parent;
//node为黑
node->colour = rbtree_colour_black;
//父节点为红
node->parent->colour = rbtree_colour_red;
//祖父节点为红
node->parent->parent->colour = rbtree_colour_red;
//node为轴左旋转
rbtree_inter_rotate_left(root, node);
//父节点为轴右旋转右旋转
rbtree_inter_rotate_right(root, node);
node = temp;
}
}
}
//如果父节点是祖父节点的右孩子
else
{
//如果伯父节点存在,且为红
if(node->parent->parent->left && rbtree_colour_red == node->parent->parent->left->colour)
{
//把父节点与伯父节点涂成黑色
node->parent->colour = rbtree_colour_black;
node->parent->parent->left->colour = rbtree_colour_black;
//把祖父结点涂成红色
node->parent->parent->colour = rbtree_colour_red;
//指针往上走
node = node->parent->parent;
}
else
{
//如果是外侧插入
if(node == node->parent->right)
{
//node为红
node->colour = rbtree_colour_red;
//父节点为黑
node->parent->colour = rbtree_colour_black;
//祖父节点为红
node->parent->parent->colour = rbtree_colour_red;
//父节点为轴左旋
rbtree_inter_rotate_left(root, node->parent);
}
else
{
myrbtree_node_t * temp = node->parent;
//node为黑
node->colour = rbtree_colour_black;
//父节点为红
node->parent->colour = rbtree_colour_red;
//祖父节点为红
node->parent->parent->colour = rbtree_colour_red;
//node为轴右旋转
rbtree_inter_rotate_right(root, node);
//父节点为轴左旋
rbtree_inter_rotate_left(root, node);
node = temp;
}
}
}
}
(*root)->colour = rbtree_colour_black;
}
/*
*
*添加一节点
*rbtree:树
*parent:新节点的父节点
*key:新节点的关键字
*
*/
static __INLINE__ void rbtree_inter_insert(myrbtree_t * rbtree, myrbtree_node_t ** root, myrbtree_node_t * node_new, myrbtree_node_t * parent)
{
assert(rbtree && node_new && root);
//如果父节点为空,表明添加的是根节点
if(NULL == parent)
{
//根节点必有黑色
node_new->colour = rbtree_colour_black;
*root = node_new;
assert(NULL == *root || NULL == (*root)->parent);
return;
}
node_new->parent = parent;
//比较节点键值与父节点键值大小
if(rbtree_inter_compare(rbtree, node_new->key,parent->key))
parent->right = node_new;
else
parent->left = node_new;
//旋转树,使之符合红黑树的规则
rbtree_inter_rebalance(root, node_new);
}
/*
*
*从rb树中删除一个节点
*
*删除除节点 z , 则可以用y完全取代z(位置,颜色,用户数据), 删除z演变成删除y
*
* 图1
* a a
* / / / /
* ? z ? y
* / / ----> / /
* ? b ? b
* / / / /
* y ? del ---> z ?
* / /
* ?1 ?1
*
*
*如果z是红色 则?1对应的子树根节点直接挪到z对应的位置,即完成了删除工作,并保证了红黑树的平衡性
*如果z是黑色 并且?1对应的子树根节点x为红色,则把?1挪到z的位置,并把x改成黑色,即完成了删除工作,并保证了红黑树的平衡性
*如果z是黑色 并且?1对应的子树根节点x也为黑色。
*图2
*
* ?
* / /
* ? x_parent
* / /
* x ?2 = w
* / /
* ? ?
*图2即最终要面临的情况
*x这个分支,由于去除了一个黑色的结点,而x又是黑色,它比 ?2 那个分支相比,"少了一个黑色的结点"
*
*图3
* x_parent x_parent->parent
* / / / /
* x w --> x_parent w_new
* / / / / / /
* ? ? ?b ?b ? ?
*假如?b ?b均为"黑" w也为黑 则把 w涂成红 此时x分支与w分支"黑层数"相同 ,
*(x_parent有可能为红,但这不影响结果,因为在下一个循环中,x = x_parent,循环将退出,x即x_parent将被涂成黑,不违反红黑树规则)
*以x = x_parent比 w = w_new这个分支"少了一层" 持续向上迭代 (x = x_parent x_parent = x->parent) 至到根节点为至,即完成了删除工作,并保证了红黑树的平衡
*
*如果w为红,通过旋转,可以演化成图3的情况
*演化步骤如下:
*把w涂成黑色,x_parent涂成红色(根据红黑树定义x_parent必为黑色, w的左右子节点必为黑色)
*以x_parent为轴左旋
* w
* / /
* x_parent ?b
* / /
* x ?b = w_new(必为黑)
* / /
* ? ?
* x 分支比 ?b分支少了一层
*
* 即,不管w为红还是为黑,最终都可以演化成w为黑的情况
*
*w的子节点中有红色节点的情况
*这种情况可以考虑把w的红色节点转移到x分支,作为x分支的根节点,并涂成黑色,即完成了删除,并保证了红黑树的平衡
*具体变换如下 如果a不为红,可以经过旋转变换为红
*
* x_parent?
* / /
* x w黑
* / / / /
* ? ? 黑b 红a
*
* w?
* / /
* x_parent黑 黑a
* / /
* x 黑b
*即完成了删除,并保证了红黑树的平衡性
*
*/
static __INLINE__ myrbtree_node_t * rbtree_inter_rebalance_for_erase(/*myrbtree_t * rbtree*/myrbtree_node_t ** root, myrbtree_node_t * node)
{
myrbtree_node_t * x = NULL;
myrbtree_node_t * x_parent = NULL;
myrbtree_node_t * y = node;
assert(node && root);
if(NULL == node->left)
x = node->right;
else if(NULL == node->right)
x = node->left;
else
{
//如果node不是叶子结点,则寻找右子树中最"左"边的那个节点替代node
y = node->right;
while(y->left)
y = y->left;
x = y->right;
}
//要删除的节点左右孩子都不为空,y与node 互换
if(y != node)
{
//颜色互换
rbtree_colour colour = y->colour;
y->colour = node->colour;
node->colour = colour;
if(node->parent)
{
if(node == node->parent->left)
node->parent->left = y;
else
node->parent->right = y;
}
else if(node == *root)
*root = y;
else
assert(0);//如果走到这一步 bug here
if(node->left)
node->left->parent = y;
//如果y是node的右孩子
if(y == node->right)
{
x_parent = y;
}
else
{
if(node->right)
node->right->parent = y;
assert(y->parent);
x_parent = y->parent;
if(y == x_parent->left)
x_parent->left = x;
else
assert(0);//x_parent->right = x; //y不可能是x_parent的右孩子 如果走到这一步,bug
y->right = node->right;
}
y->parent = node->parent;
y->left = node->left;
y = node;
}
else//y就是要删除的节点,不必做替换,且y必有一孩子节点为空
{
//如果要删除的是根节点
if(y == *root)
{
*root = x;
if(*root)
{
(*root)->colour = rbtree_colour_black;
(*root)->parent = NULL;
}
assert(NULL == *root || NULL == (*root)->parent);
return y;
}
else
{
assert(y->parent);
x_parent = y->parent;
if(y == x_parent->left)
x_parent->left = x;
else
x_parent->right = x;
}
}
assert(x_parent);
if(x)
x->parent = x_parent;
//转化成
//* a a
//* / / / /
//* ? z ? y
//* / / ----> / /
//* ? b ? b
//* / / / /
//* y ? del ---> z ?
//* / /
//* ?1 ?1
//如果要删除的节点为红色,函数返回
if(y->colour == rbtree_colour_red)
{
assert(NULL == *root || NULL == (*root)->parent);
return y;
}
while((x != *root) && (x == NULL || rbtree_colour_black == x->colour))
{
assert(x_parent);
if(x == x_parent->left)
{
myrbtree_node_t * w = x_parent->right;
assert(w);//x分支为0/1个黑结点,w分支至少有一个黑结点,所以w分支不可能为null,
//如果w是红,需要进行转换,
if(rbtree_colour_red == w->colour)
{
//x_parent必定是黑色的,且w的两个子节点必不空,且一定为黑色
assert(rbtree_colour_black == x_parent->colour);
assert(w->left && rbtree_colour_black == w->left->colour);
assert(w->right && rbtree_colour_black == w->right->colour);
w->colour = rbtree_colour_black;
x_parent->colour = rbtree_colour_red;
//旋转
rbtree_inter_rotate_left(root, w);
w = x_parent->right;
}
//x分支比w分支"少了一层",且x,w均为黑
assert(w);
//如果w的左右子节点均为黑
if( (NULL == w->left || rbtree_colour_black == w->left->colour) &&
(NULL == w->right || rbtree_colour_black == w->right->colour) )
{
//x_parent有可能为红,但这不影响结果,因为在下一个循环中,x = x_parent,循环将退出,x即x_parent将被涂成黑,不违反红黑树规则
w->colour = rbtree_colour_red;
x = x_parent;
x_parent = x->parent;
continue;
}
//如果至少有一个子节点为红, 通过旋转变换,让为红的那个节点始终为右节点
if(NULL == w->right || rbtree_colour_black == w->right->colour)
{
assert(w->left && rbtree_colour_red == w->left->colour);//根据逻辑得出,必为不空,且必为红色
w->left->colour = rbtree_colour_black;
w->colour = rbtree_colour_red;
rbtree_inter_rotate_right(root, w->left);
w = x_parent->right;
}
//现在演变成这种情况
//* x_parent?
//* / /
//* x w黑
//* / / / /
//* ? ? ?b 红a
assert(w->right && rbtree_colour_red == w->right->colour);//根据逻辑,这个条件必成立
//旋转,完成了平衡的工作,变换过程如下图
//* x_parent?
//* / /
//* x w黑
//* / / / /
//* ? ? 黑b 红a
//*
//* w?
//* / /
//* x_parent黑 黑a
//* / /
//* x 黑b
w->colour = x_parent->colour;
x_parent->colour = rbtree_colour_black;
w->right->colour = rbtree_colour_black;
rbtree_inter_rotate_left(root, w);
break;
}
else//x 是 x_parent的右孩子,操作与x == x_parent->left相同,但左右相反
{
myrbtree_node_t * w = x_parent->left;
assert(w);//x分支为0/1个黑结点,w分支至少有一个黑结点,所以w分支不可能为null,
//如果w是红,需要进行转换,
if(rbtree_colour_red == w->colour)
{
//x_parent必定是黑色的,且w的两个子节点必不空,且一定为黑色
assert(rbtree_colour_black == x_parent->colour);
assert(w->left && rbtree_colour_black == w->left->colour);
assert(w->right && rbtree_colour_black == w->right->colour);
w->colour = rbtree_colour_black;
x_parent->colour = rbtree_colour_red;
//旋转
rbtree_inter_rotate_right(root, w);
w = x_parent->left;
}
//x分支比w分支"少了一层",且x,w均为黑
assert(w);
//如果w的左右子节点均为黑
if( (NULL == w->left || rbtree_colour_black == w->left->colour) &&
(NULL == w->right || rbtree_colour_black == w->right->colour) )
{
//x_parent有可能为红,但这不影响结果,因为在下一个循环中,x = x_parent,循环将退出,x即x_parent将被涂成黑,不违反红黑树规则
w->colour = rbtree_colour_red;
x = x_parent;
x_parent = x->parent;
continue;
}
//如果至少有一个子节点为红, 通过旋转变换,让为红的那个节点始终为右节点
if(NULL == w->left || rbtree_colour_black == w->left->colour)
{
assert(w->right && rbtree_colour_red == w->right->colour);//根据逻辑得出,必为不空,且必为红色
w->right->colour = rbtree_colour_black;
w->colour = rbtree_colour_red;
rbtree_inter_rotate_left(root, w->right);
w = x_parent->left;
}
assert(w->left && rbtree_colour_red == w->left->colour);//根据逻辑,这个条件必成立
w->colour = x_parent->colour;
x_parent->colour = rbtree_colour_black;
w->left->colour = rbtree_colour_black;
rbtree_inter_rotate_right(root, w);
break;
}
}
if(x)
x->colour = rbtree_colour_black;
//assert(!rbtree_inter_ismynode(rbtree->root, y));
assert(NULL == (*root) || NULL == (*root)->parent);
return y;
}
static __INLINE__ void rbtree_inter_del(myrbtree_t * rbtree, myrbtree_node_t ** root, myrbtree_node_t * node, void ** key, void ** data)
{
assert(rbtree && node && root);
//旋转平衡红黑树
node = rbtree_inter_rebalance_for_erase(root, node);
if(NULL == node)
return;
if(data)
*data = node->data;
if(key)
*key = node->key;
//销毁node
rbtree_inter_destroy_node(rbtree, node);
}
static __INLINE__ int rbtree_inter_countlayer(myrbtree_node_t * root, int bmax)
{
int left = 0;
int right = 0;
if(NULL == root)
return 0;
left = rbtree_inter_countlayer(root->left, bmax);
right = rbtree_inter_countlayer(root->right, bmax);
if(left > right && bmax)
return left + 1;
else
return right + 1;
}
static __INLINE__ myrbtree_node_t * rbtree_inter_begin(myrbtree_t * rbtree)
{
myrbtree_node_t * node;
assert(rbtree);
node = rbtree->root;
if(NULL == node)
return NULL;
while(node->left)
node = node->left;
return node;
}
static __INLINE__ myrbtree_node_t * rbtree_inter_end(myrbtree_t * rbtree)
{
myrbtree_node_t * node;
assert(rbtree);
node = rbtree->root;
if(NULL == node)
return NULL;
while(node->right)
node = node->right;
return node;
}
static __INLINE__ void rbtree_inter_erase(myrbtree_t * rbtree, myrbtree_node_t * node)
{
assert(node);
while(node)
{
myrbtree_node_t * y = node->left;
if(node->right)
rbtree_inter_erase(rbtree, node->right);
rbtree_inter_destroy_node(rbtree, node);
node = y;
}
}
static __INLINE__ int rbtree_inter_realcount(myrbtree_node_t * root)
{
int left = 0;
int right = 0;
if(NULL == root)
return 0;
if(root->left)
left = rbtree_inter_realcount(root->left);
if(root->right)
right = rbtree_inter_realcount(root->right);
return left + right + 1;
}
static __INLINE__ int rbtree_inter_examin(myrbtree_t * rbtree, myrbtree_node_t * node)
{
int left = 0;
int right = 0;
if(NULL == node)
return 0;
if(node->left)
{
assert(rbtree_inter_compare(rbtree, node->key, node->left->key));
assert(node->left->parent == node);
left = rbtree_inter_examin(rbtree, node->left);
}
if(node->right)
{
assert(rbtree_inter_compare(rbtree, node->right->key, node->key));
assert(node->right->parent == node);
right = rbtree_inter_examin(rbtree, node->right);
}
assert(left == right);
if(rbtree_colour_black == node->colour)
return left + 1;
else
return left;
}
/*
*
*创建rb树
*
*/
HMYRBTREE MyRBTreeConstruct(HMYMEMPOOL hm, myrbtree_compare compare)
{
myrbtree_t * rbtree = NULL;
rbtree = (myrbtree_t *)MyMemPoolMalloc(hm, sizeof(*rbtree));
if(NULL == rbtree)
return NULL;
rbtree->compare = compare;
rbtree->hm = hm;
rbtree->root = NULL;
return (HMYRBTREE)rbtree;
}
/*
*
*销毁rb树
*
*/
void MyRBTreeDestruct(HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return;
//遍历树,释放每个节点
if(rbtree->root)
rbtree_inter_erase(rbtree, rbtree->root);
MyMemPoolFree(rbtree->hm, rbtree);
}
/*
*
*删除所有节点
*
*/
void MyRBTreeClear(HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return;
if(NULL == rbtree->root)
return;
//遍历树,释放每个节点
rbtree_inter_erase(rbtree, rbtree->root);
rbtree->root = NULL;
}
/*
*
*往rb树中插入一个节点
*
*/
HMYRBTREE_ITER MyRBTreeInsertEqual(HMYRBTREE htree, const void * key, const void * userdata)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
myrbtree_node_t * node_new = NULL;
myrbtree_node_t * parent = NULL;
if(NULL == rbtree)
return NULL;
rbtree_inter_searchex(rbtree, rbtree->root, key, &parent);
node_new = rbtree_inter_create_node(rbtree, key, userdata);
if(NULL == node_new)
return NULL;
rbtree_inter_insert(rbtree, &rbtree->root, node_new, parent);
return (HMYRBTREE_ITER)node_new;
}
/*
*
*往rb树中插入一个节点
*
*/
HMYRBTREE_ITER MyRBTreeInsertUnique(HMYRBTREE htree, const void * key, const void * userdata)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
myrbtree_node_t * parent = NULL;
myrbtree_node_t * node_new = NULL;
if(NULL == rbtree)
return NULL;
node_new = rbtree_inter_searchex(rbtree, rbtree->root, key, &parent);
if(node_new != NULL)
return (HMYRBTREE_ITER)node_new;
node_new = rbtree_inter_create_node(rbtree, key, userdata);
if(NULL == node_new)
return NULL;
rbtree_inter_insert(rbtree, &rbtree->root, node_new, parent);
return (HMYRBTREE_ITER)node_new;
}
/*
*
*从rb树中删除一个节点 iter失效
*
*/
void MyRBTreeDelIter(HMYRBTREE htree, HMYRBTREE_ITER iter, void ** key, void ** data)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
myrbtree_node_t * node = (myrbtree_node_t *)iter;
if(NULL == rbtree || NULL == node)
return;
assert(rbtree_inter_search(rbtree, rbtree->root, node->key));
rbtree_inter_del(rbtree, &(rbtree->root), node, key, data);
}
/*
*
*根据键值删除一个节点
*成功删除返回0, 否则返回-1
*
*/
int MyRBTreeDelKey(HMYRBTREE htree, const void * key, void ** key_ret, void ** data_ret)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
myrbtree_node_t * node = NULL;
if(NULL == rbtree)
return -1;
node = rbtree_inter_search(rbtree, rbtree->root, key);
if(NULL == node)
return -1;
rbtree_inter_del(rbtree, &(rbtree->root), node, key_ret, data_ret);
return 0;
}
/*
*
*获取节点的用户数据
*
*/
void * MyRBTreeGetIterData(const HMYRBTREE_ITER iter)
{
myrbtree_node_t * node = (myrbtree_node_t *)iter;
if(NULL == node)
return NULL;
return node->data;
}
/*
*
*获取节点的键
*
*/
const void * MyRBTreeGetIterKey(const HMYRBTREE_ITER iter)
{
myrbtree_node_t * node = (myrbtree_node_t *)iter;
if(NULL == node)
return NULL;
return node->key;
}
/*
*
*查找节点
*
*/
HMYRBTREE_ITER MyRBTreeSearch(const HMYRBTREE htree, const void * key)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
myrbtree_node_t * node = NULL;
if(NULL == rbtree || NULL == rbtree->compare)
return NULL;
node = rbtree_inter_search(rbtree, rbtree->root, key);
return (HMYRBTREE_ITER)node;
}
/*
*
*计算最大层数
*
*/
int MyRBTreeLayer(const HMYRBTREE htree, int bmax)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return 0;
return rbtree_inter_countlayer(rbtree->root, bmax);
}
/*
*
*"获取第一个节点"
*
*/
HMYRBTREE_ITER MyRBTreeBegin(const HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return 0;
return (HMYRBTREE_ITER)rbtree_inter_begin(rbtree);
}
/*
*
*"获取最后一个节点"
*
*/
HMYRBTREE_ITER MyRBTreeEnd(const HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return 0;
return (HMYRBTREE_ITER)rbtree_inter_end(rbtree);
}
/*
*
*获取下一个节点
*
*/
HMYRBTREE_ITER MyRBTreeGetNext(const HMYRBTREE_ITER it)
{
myrbtree_node_t * node = (myrbtree_node_t *)it;
if(NULL == node)
return NULL;
if(NULL == node->right)
{
while(node->parent && node == node->parent->right)
node = node->parent;
if(node->parent && node == node->parent->left)
return (HMYRBTREE_ITER)node->parent;
else
return NULL;
}
else
{
node = node->right;
while(node->left)
node = node->left;
return (HMYRBTREE_ITER)node;
}
}
/*
*
*获取上一个节点
*
*/
HMYRBTREE_ITER MyRBTreeGetPrev(const HMYRBTREE_ITER it)
{
myrbtree_node_t * node = (myrbtree_node_t *)it;
if(node->left)
{
node = node->left;
while(node->right)
node = node->right;
return (HMYRBTREE_ITER)node;
}
else
{
while(node->parent && node == node->parent->left)
node = node->parent;
if(node->parent && node == node->parent->right)
return (HMYRBTREE_ITER)node->parent;
else
return NULL;
}
}
/*
*
*检查红黑树是否合法
*
*/
int MyRBTreeExamin(const HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return 0;
return rbtree_inter_examin(rbtree, rbtree->root);
}
/*
*
*获取个数
*
*/
int MyRBTreeGetRealCount(const HMYRBTREE htree)
{
myrbtree_t * rbtree = (myrbtree_t *)htree;
if(NULL == rbtree)
return 0;
return rbtree_inter_realcount(rbtree->root);
}
#include "mymap.c"
#ifdef WIN32
#include "MyStringSetEx.c"
#endif
==========================================================
mymempool.h
/*
*
* mymempool.h 内存池
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#ifndef __MYMEMPOOL_H__
#define __MYMEMPOOL_H__
#include "myconfig.h"
#include <stdlib.h>
/**
* @brief 分配内存的回调函数
*/
typedef void *(*mymalloc)(size_t size, void * context_data);
/**
* @brief 释放内存的回调函数
*/
typedef void(*myfree)(void *, void * context_data);
/**
* @brief 观察内存池回调
*/
typedef void(*mempool_view)(void * context_data, void * info, size_t info_size);
/**
* @brief 内存池销毁时的回调函数
*/
typedef void(*mempool_destroy)(void * context_data);
typedef struct __handle_mymempool
{int unused;} * HMYMEMPOOL;
/*
*
*构造内存池
*
*/
extern HMYMEMPOOL MyMemPoolConstruct(mymalloc malloc_helper, myfree free_helper, mempool_destroy destroy, mempool_view view, void * context_data);
/*
*
*销毁内存池
*
*/
extern void MyMemePoolDestruct(HMYMEMPOOL hm);
/*
*
*观察内存池
* @param info:返回的内存信息缓冲区
* @param info_size:info的大小
*
*/
extern void MyMemPoolView(HMYMEMPOOL hm, void * info, size_t info_size);
/*
*
*分配内存
*
*/
#ifdef MEM_LEAK_CHECK
extern void * MemPoolMalloc(HMYMEMPOOL hm,size_t size, char * file, int line);
#define MyMemPoolMalloc(h, s) MemPoolMalloc(h, s, __FILE__, __LINE__);
#else
extern void * MyMemPoolMalloc(HMYMEMPOOL hm,size_t size);
#endif
/*
*
*释放内存
*
*/
extern void MyMemPoolFree(HMYMEMPOOL hm, void * ptr);
/*
*
*内存是否泄漏报告
*
*/
extern void MyMemPoolMemReport(int needassert);
/*
*
*获取分配了多少内存
*
*/
extern int MyMemPoolGetBlkCount();
#endif
*
* mymempool.h 内存池
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#ifndef __MYMEMPOOL_H__
#define __MYMEMPOOL_H__
#include "myconfig.h"
#include <stdlib.h>
/**
* @brief 分配内存的回调函数
*/
typedef void *(*mymalloc)(size_t size, void * context_data);
/**
* @brief 释放内存的回调函数
*/
typedef void(*myfree)(void *, void * context_data);
/**
* @brief 观察内存池回调
*/
typedef void(*mempool_view)(void * context_data, void * info, size_t info_size);
/**
* @brief 内存池销毁时的回调函数
*/
typedef void(*mempool_destroy)(void * context_data);
typedef struct __handle_mymempool
{int unused;} * HMYMEMPOOL;
/*
*
*构造内存池
*
*/
extern HMYMEMPOOL MyMemPoolConstruct(mymalloc malloc_helper, myfree free_helper, mempool_destroy destroy, mempool_view view, void * context_data);
/*
*
*销毁内存池
*
*/
extern void MyMemePoolDestruct(HMYMEMPOOL hm);
/*
*
*观察内存池
* @param info:返回的内存信息缓冲区
* @param info_size:info的大小
*
*/
extern void MyMemPoolView(HMYMEMPOOL hm, void * info, size_t info_size);
/*
*
*分配内存
*
*/
#ifdef MEM_LEAK_CHECK
extern void * MemPoolMalloc(HMYMEMPOOL hm,size_t size, char * file, int line);
#define MyMemPoolMalloc(h, s) MemPoolMalloc(h, s, __FILE__, __LINE__);
#else
extern void * MyMemPoolMalloc(HMYMEMPOOL hm,size_t size);
#endif
/*
*
*释放内存
*
*/
extern void MyMemPoolFree(HMYMEMPOOL hm, void * ptr);
/*
*
*内存是否泄漏报告
*
*/
extern void MyMemPoolMemReport(int needassert);
/*
*
*获取分配了多少内存
*
*/
extern int MyMemPoolGetBlkCount();
#endif
======================================================
mymempool.c
/*
*
* mymempool.c 内存池
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#include "mymempool.h"
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
/**
* 多线程安全(内存泄漏检测)
*/
#ifndef WIN32
#include <pthread.h>
#else
#include <windows.h>
#define pthread_mutex_t CRITICAL_SECTION
#define pthread_mutex_init(cs, x) do{ InitializeCriticalSection(cs); }while(0)
#define pthread_mutex_lock(cs) do{ EnterCriticalSection(cs); }while(0)
#define pthread_mutex_unlock(cs) do{ LeaveCriticalSection(cs); }while(0)
#endif
/**
* 记录内存分配函数
*/
#ifdef MEM_LEAK_CHECK
static void add_to_meminfo_list(const char * file, const int line, const void * ptr, size_t size);
static void del_from_meminfo_list(const void * ptr);
static int meminfo_report(int, int);
#endif
typedef struct __mymempool_t
{
mymalloc malloc_fun;
myfree free_fun;
mempool_view view_fun;
mempool_destroy destroy_fun;
/*
* 用户自定义的上下文数据
*/
void * context_data;
}mymempool_t;
/*
*
*构造内存池
*
*/
HMYMEMPOOL MyMemPoolConstruct(mymalloc malloc_helper, myfree free_helper, mempool_destroy destroy, mempool_view view, void * context_data)
{
mymempool_t * mp = NULL;
assert(malloc_helper && free_helper);
mp = (mymempool_t *)malloc(sizeof(*mp));
assert(mp);
mp->destroy_fun = destroy;
mp->context_data = context_data;
mp->malloc_fun = malloc_helper;
mp->free_fun = free_helper;
mp->view_fun = view;
return (HMYMEMPOOL)mp;
}
/*
*
*销毁内存池
*
*/
void MyMemePoolDestruct(HMYMEMPOOL hm)
{
mymempool_t * mp = (mymempool_t *)hm;
assert(mp);
if(mp->destroy_fun)
mp->destroy_fun(mp->context_data);
free(mp);
}
/*
*
*观察内存池
*
*/
void MyMemPoolView(HMYMEMPOOL hm, void * info, size_t info_size)
{
mymempool_t * mp = (mymempool_t *)hm;
assert(mp);
if(mp->view_fun)
mp->view_fun(mp->context_data, info, info_size);
}
/*
*
*分配内存
*
*/
#ifdef MEM_LEAK_CHECK
void * MemPoolMalloc(HMYMEMPOOL hm,size_t size, char * file, int line)
#else
void * MyMemPoolMalloc(HMYMEMPOOL hm,size_t size)
#endif
{
mymempool_t * mp = (mymempool_t *)hm;
void * ptr = NULL;
if(mp)
ptr = mp->malloc_fun(size, mp->context_data);
else
ptr = malloc(size);
#ifdef MEM_LEAK_CHECK
//添加到内存分配表
add_to_meminfo_list(file, line, ptr, size);
#endif
return ptr;
}
/*
*
*释放内存
*
*/
void MyMemPoolFree(HMYMEMPOOL hm, void * ptr)
{
mymempool_t * mp = (mymempool_t *)hm;
#ifdef MEM_LEAK_CHECK
//从内存分配表中删除
del_from_meminfo_list(ptr);
#endif
if(mp)
mp->free_fun(ptr, mp->context_data);
else
free(ptr);
}
#ifdef MEM_LEAK_CHECK
/*
*
*获取做了几次内存分配操作
*
*/
int MyMemPoolGetBlkCount()
{
return meminfo_report(0, 0);
}
/*
*
*内存分配报告
*
*/
void MyMemPoolMemReport(int needassert)
{
meminfo_report(needassert, 1);
}
/**
* 返回全局的锁对象指针
*/
static void * get_meminfo_lock()
{
static int b_init = 0;
static pthread_mutex_t mem_lock;
if(!b_init)
{
pthread_mutex_init(&mem_lock, NULL);
b_init = 1;
}
return &mem_lock;
}
/**
* 内存记录表加锁
*/
static void meminfo_lock()
{
pthread_mutex_lock((pthread_mutex_t *)get_meminfo_lock());
}
/**
* 内存记录表解锁
*/
static void meminfo_unlock()
{
pthread_mutex_unlock((pthread_mutex_t *)get_meminfo_lock());
}
/**
* 内存分配记录表条目信息
*/
static struct __mymeminfo
{
char file[64];
int line;
size_t size;
void * ptr;
struct __mymeminfo * next;
struct __mymeminfo * prev;
} * head_meminfo_list = NULL;
/**
* 往内存分配记录表里添加一条记录
*/
static void add_to_meminfo_list(const char * file, const int line, const void * ptr, size_t size)
{
struct __mymeminfo * info = (struct __mymeminfo *)malloc(sizeof(*info));
memset(info, 0, sizeof(*info));
//加锁
meminfo_lock();
strncpy(info->file, file, sizeof(info->file));
info->line = line;
info->ptr = (void *)ptr;
info->size = size;
info->next = head_meminfo_list;
if(head_meminfo_list)
head_meminfo_list->prev = info;
head_meminfo_list = info;
//解锁
meminfo_unlock();
}
/**
* 往内存分配记录表里删除一条记录
*/
static void del_from_meminfo_list(const void * ptr)
{
struct __mymeminfo * info = NULL;
//加锁
meminfo_lock();
info = head_meminfo_list;
while(info)
{
if(ptr != info->ptr)
{
info = info->next;
continue;
}
if(info->prev)
info->prev->next = info->next;
if(info->next)
info->next->prev = info->prev;
if(info == head_meminfo_list)
head_meminfo_list = info->next;
free(info);
break;
}
//解锁
meminfo_unlock();
}
/**
* 内存分配报告,用于检测是否出现了内存泄漏
*/
static int meminfo_report(int needassert, int bprintf)
{
struct __mymeminfo * info = NULL;
int leak_count = 0;
printf("/n======== mem leak report begin ========/n");
//加锁
meminfo_lock();
info = head_meminfo_list;
while(info)
{
if(bprintf)
{
#ifdef _MBCSV6
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, info->ptr);
#else
#ifdef WIN32
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, (long long)info->ptr);
#else
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, info->ptr);
#endif
#endif
}
info = info->next;
leak_count ++;
}
//解锁
meminfo_unlock();
printf("mem leak %d/n", leak_count);
printf("======== mem leak report end ==========/n/n");
if(needassert)
assert(0 == leak_count);
return leak_count;
}
#else
void MyMemPoolMemReport(int needassert){}
int MyMemPoolGetBlkCount(){return 0;}
#endif
*
* mymempool.c 内存池
*
* author:lin shao chuan (email:lsccsl@tom.com, msn:lsccsl@163.net)
*
*/
#include "mymempool.h"
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
/**
* 多线程安全(内存泄漏检测)
*/
#ifndef WIN32
#include <pthread.h>
#else
#include <windows.h>
#define pthread_mutex_t CRITICAL_SECTION
#define pthread_mutex_init(cs, x) do{ InitializeCriticalSection(cs); }while(0)
#define pthread_mutex_lock(cs) do{ EnterCriticalSection(cs); }while(0)
#define pthread_mutex_unlock(cs) do{ LeaveCriticalSection(cs); }while(0)
#endif
/**
* 记录内存分配函数
*/
#ifdef MEM_LEAK_CHECK
static void add_to_meminfo_list(const char * file, const int line, const void * ptr, size_t size);
static void del_from_meminfo_list(const void * ptr);
static int meminfo_report(int, int);
#endif
typedef struct __mymempool_t
{
mymalloc malloc_fun;
myfree free_fun;
mempool_view view_fun;
mempool_destroy destroy_fun;
/*
* 用户自定义的上下文数据
*/
void * context_data;
}mymempool_t;
/*
*
*构造内存池
*
*/
HMYMEMPOOL MyMemPoolConstruct(mymalloc malloc_helper, myfree free_helper, mempool_destroy destroy, mempool_view view, void * context_data)
{
mymempool_t * mp = NULL;
assert(malloc_helper && free_helper);
mp = (mymempool_t *)malloc(sizeof(*mp));
assert(mp);
mp->destroy_fun = destroy;
mp->context_data = context_data;
mp->malloc_fun = malloc_helper;
mp->free_fun = free_helper;
mp->view_fun = view;
return (HMYMEMPOOL)mp;
}
/*
*
*销毁内存池
*
*/
void MyMemePoolDestruct(HMYMEMPOOL hm)
{
mymempool_t * mp = (mymempool_t *)hm;
assert(mp);
if(mp->destroy_fun)
mp->destroy_fun(mp->context_data);
free(mp);
}
/*
*
*观察内存池
*
*/
void MyMemPoolView(HMYMEMPOOL hm, void * info, size_t info_size)
{
mymempool_t * mp = (mymempool_t *)hm;
assert(mp);
if(mp->view_fun)
mp->view_fun(mp->context_data, info, info_size);
}
/*
*
*分配内存
*
*/
#ifdef MEM_LEAK_CHECK
void * MemPoolMalloc(HMYMEMPOOL hm,size_t size, char * file, int line)
#else
void * MyMemPoolMalloc(HMYMEMPOOL hm,size_t size)
#endif
{
mymempool_t * mp = (mymempool_t *)hm;
void * ptr = NULL;
if(mp)
ptr = mp->malloc_fun(size, mp->context_data);
else
ptr = malloc(size);
#ifdef MEM_LEAK_CHECK
//添加到内存分配表
add_to_meminfo_list(file, line, ptr, size);
#endif
return ptr;
}
/*
*
*释放内存
*
*/
void MyMemPoolFree(HMYMEMPOOL hm, void * ptr)
{
mymempool_t * mp = (mymempool_t *)hm;
#ifdef MEM_LEAK_CHECK
//从内存分配表中删除
del_from_meminfo_list(ptr);
#endif
if(mp)
mp->free_fun(ptr, mp->context_data);
else
free(ptr);
}
#ifdef MEM_LEAK_CHECK
/*
*
*获取做了几次内存分配操作
*
*/
int MyMemPoolGetBlkCount()
{
return meminfo_report(0, 0);
}
/*
*
*内存分配报告
*
*/
void MyMemPoolMemReport(int needassert)
{
meminfo_report(needassert, 1);
}
/**
* 返回全局的锁对象指针
*/
static void * get_meminfo_lock()
{
static int b_init = 0;
static pthread_mutex_t mem_lock;
if(!b_init)
{
pthread_mutex_init(&mem_lock, NULL);
b_init = 1;
}
return &mem_lock;
}
/**
* 内存记录表加锁
*/
static void meminfo_lock()
{
pthread_mutex_lock((pthread_mutex_t *)get_meminfo_lock());
}
/**
* 内存记录表解锁
*/
static void meminfo_unlock()
{
pthread_mutex_unlock((pthread_mutex_t *)get_meminfo_lock());
}
/**
* 内存分配记录表条目信息
*/
static struct __mymeminfo
{
char file[64];
int line;
size_t size;
void * ptr;
struct __mymeminfo * next;
struct __mymeminfo * prev;
} * head_meminfo_list = NULL;
/**
* 往内存分配记录表里添加一条记录
*/
static void add_to_meminfo_list(const char * file, const int line, const void * ptr, size_t size)
{
struct __mymeminfo * info = (struct __mymeminfo *)malloc(sizeof(*info));
memset(info, 0, sizeof(*info));
//加锁
meminfo_lock();
strncpy(info->file, file, sizeof(info->file));
info->line = line;
info->ptr = (void *)ptr;
info->size = size;
info->next = head_meminfo_list;
if(head_meminfo_list)
head_meminfo_list->prev = info;
head_meminfo_list = info;
//解锁
meminfo_unlock();
}
/**
* 往内存分配记录表里删除一条记录
*/
static void del_from_meminfo_list(const void * ptr)
{
struct __mymeminfo * info = NULL;
//加锁
meminfo_lock();
info = head_meminfo_list;
while(info)
{
if(ptr != info->ptr)
{
info = info->next;
continue;
}
if(info->prev)
info->prev->next = info->next;
if(info->next)
info->next->prev = info->prev;
if(info == head_meminfo_list)
head_meminfo_list = info->next;
free(info);
break;
}
//解锁
meminfo_unlock();
}
/**
* 内存分配报告,用于检测是否出现了内存泄漏
*/
static int meminfo_report(int needassert, int bprintf)
{
struct __mymeminfo * info = NULL;
int leak_count = 0;
printf("/n======== mem leak report begin ========/n");
//加锁
meminfo_lock();
info = head_meminfo_list;
while(info)
{
if(bprintf)
{
#ifdef _MBCSV6
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, info->ptr);
#else
#ifdef WIN32
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, (long long)info->ptr);
#else
printf("[%s:%d] %3d - %x /n", info->file, info->line, info->size, info->ptr);
#endif
#endif
}
info = info->next;
leak_count ++;
}
//解锁
meminfo_unlock();
printf("mem leak %d/n", leak_count);
printf("======== mem leak report end ==========/n/n");
if(needassert)
assert(0 == leak_count);
return leak_count;
}
#else
void MyMemPoolMemReport(int needassert){}
int MyMemPoolGetBlkCount(){return 0;}
#endif
呵呵,相信如果不是对红黑树很感兴趣的人,是不会看到这里的,
笔者简介:林绍川
目前主要从事嵌入式开发,对算法有浓厚的兴趣欢迎交流
lsccsl@tom.com
写这个算法的主要原因是,在嵌入式开发过程中,有时使用stl是件麻烦的事。图省心,写了一些常用的容器,如hash rbtree list等,需要相应的源码请email给我。have fun :)
或者从 http://sourceforge.net/projects/foolib/files/ 下载