rb_node_t * rb_insert(const key_type key, const value_type value, rb_node_t **root)
{
rb_node_t *parent = NULL, *node = NULL;
int32_t ret = 0;
if (( node = rb_search_auxiliary(*root,key,&parent)))
{
return NULL;
}
node = rb_node_new(key,value);
node->color = RED;
node->parent = parent;
//ret = key - parent->key;
if ( parent )
{
if ( ret > 0 )
{
parent->right = node;
}else if ( ret < 0 )
{
parent ->left = node;
}
}else
{
//空树
*root = node;
}
return rb_insert_rebalance(node,root);
}
rb_node_t *rb_insert(key_t key, data_t data, rb_node_t *root)
{
rb_node_t *parent = NULL;
rb_node_t *node = NULL;
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_add_node( rb_node_t* adnode, rb_node_t **root)
{
rb_node_t *parent = NULL, *node = NULL;
int32_t ret = 0;
if (( node = rb_search_auxiliary(*root,adnode->key,&parent)))
{
//found,cannot insert repeatly,so return
return NULL;
}
adnode->color = RED;
adnode->parent = parent;
//ret = adnode->key - parent->key;
if ( parent )
{
if ( ret > 0 )
{
parent->right = adnode;
}else if ( ret < 0 )
{
parent ->left = adnode;
}
}else
{
//空树
*root = adnode;
}
return rb_insert_rebalance(adnode,root);
}
//四、红黑树的插入
//---------------------------------------------------------
//红黑树的插入结点
rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)
{
rb_node_t *parent = NULL, *node;
parent = NULL;
//调用rb_search_auxiliary找到插入结点的地方
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_insert_rebalance修复红黑树的性质
}
void* RBTree_GetData( RBTree* rbt, int key )
{
RBTreeNode *node;
node = rb_search_auxiliary( rbt->root, key, NULL, rbt->compare, NULL );
if( node ) {
return node->data;
}
return NULL;
}
void* RBTree_CustomGetData( RBTree* rbt, const void *keydata )
{
RBTreeNode *node;
node = rb_search_auxiliary( rbt->root, 0, keydata, rbt->compare, NULL );
if( node ) {
return node->data;
}
return NULL;
}
/** 删除红黑树中的结点 */
static int rb_erase( RBTree *rbt, int key, const void *keydata )
{
RBTreeNode *node;
/* 查找要删除的结点 */
node = rb_search_auxiliary( rbt->root, key, keydata,
rbt->compare, NULL );
if( !node ) {
return -1;
}
rb_erase_by_node( rbt, node );
return 0;
}
static RBTreeNode*
rb_insert( RBTree *rbt, int key, const void *keydata, void *data )
{
RBTreeNode *root, *node, *parent_node;
parent_node = NULL;
root = rbt->root;
node = rb_search_auxiliary( root, key, keydata,
rbt->compare, &parent_node );
if( node ) {
return NULL;
}
node = (RBTreeNode*)malloc( sizeof(RBTreeNode) );
node->left = NULL;
node->parent = parent_node;
node->right = NULL;
node->data = data;
node->key = key;
node->color = RED;
if( parent_node ) {
if( rbt->compare && keydata ) {
if( rbt->compare( parent_node->data, keydata ) > 0 ) {
parent_node->left = node;
} else {
parent_node->right = node;
}
} else {
if( parent_node->key > key ) {
parent_node->left = node;
} else {
parent_node->right = node;
}
}
} else {
root = node;
}
rbt->total_node += 1;
/* 调整红黑树的平衡 */
rbt->root = rb_insert_rebalance( root, node );
return node;
}
static int
rb_insert( rb_tree_t *rbt, mem_data_t *data, rb_data_type_t type )
{
rb_node_t *root, *node, *parent_node;
parent_node = NULL;
root = rbt->root;
node = rb_search_auxiliary( root, data, type, &parent_node );
if( node ) {
return -1;
}
node = (rb_node_t*)malloc( sizeof(rb_node_t) );
node->left = NULL;
node->parent = parent_node;
node->right = NULL;
node->mem_data = *data;
node->color = RED;
if( parent_node ) {
if( type == RB_DATA_TYPE_ADDR ) {
if( parent_node->mem_data.mem_blk.mem_addr
> data->mem_blk.mem_addr ) {
parent_node->left = node;
} else {
parent_node->right = node;
}
} else {
if( parent_node->mem_data.mem_info.class_id
> data->mem_info.class_id ) {
parent_node->left = node;
} else {
parent_node->right = node;
}
}
} else {
root = node;
}
/* 调整红黑树的平衡 */
rbt->root = rb_insert_rebalance( root, node );
return 0;
}
RBTreeNode* RBTree_CustomSearch( RBTree* rbt, const void *keydata )
{
return rb_search_auxiliary( rbt->root, 0, keydata, rbt->compare, NULL );
}
/*
如果需要删除的节点有两个儿子，那么问题可以被转化成删除另一个只有一个儿子的节点的问题（为了表述方便，这里所指的儿子，为非叶子节点的儿子）。对于二叉查找树，在删除带有两个非叶子儿子的节点的时候，我们找到要么在它的左子树中的最大元素、要么在它的右子树中的最小元素，并把它的值转移到要删除的节点中(如在这里所展示的那样)。我们接着删除我们从中复制出值的那个节点，它必定有少于两个非叶子的儿子。因为只是复制了一个值而不违反任何属性，这就把问题简化为如何删除最多有一个儿子的节点的问题。它不关心这个节点是最初要删除的节点还是我们从中复制出值的那个节点。
在本文余下的部分中，我们只需要讨论删除只有一个儿子的节点(如果它两个儿子都为空，即均为叶子，我们任意将其中一个看作它的儿子)。如果我们删除一个红色节点（此时该节点的儿子将都为叶子节点），它的父亲和儿子一定是黑色的。所以我们可以简单的用它的黑色儿子替换它，并不会破坏属性3和4。通过被删除节点的所有路径只是少了一个红色节点，这样可以继续保证属性5。另一种简单情况是在被删除节点是黑色而它的儿子是红色的时候。如果只是去除这个黑色节点，用它的红色儿子顶替上来的话，会破坏属性5，但是如果我们重绘它的儿子为黑色，则曾经通过它的所有路径将通过它的黑色儿子，这样可以继续保持属性5。
需要进一步讨论的是在要删除的节点和它的儿子二者都是黑色的时候，这是一种复杂的情况。我们首先把要删除的节点替换为它的儿子。出于方便，称呼这个儿子为N(在新的位置上)，称呼它的兄弟(它父亲的另一个儿子)为S
*/
rb_node_t *rb_erase(key_t key, rb_node_t *root)
{
rb_node_t *child;
rb_node_t *parent;
rb_node_t *old; //要删除的节点的copy
rb_node_t *left;
rb_node_t *node;//要删除的节点
color_t color;
if (!(node = rb_search_auxiliary(key, root, NULL))) {
printf("key is not exist !/n");
return root;
}
old = node;
if (node->left && node->right) { //当要删除的节点的左右子节点都不为NULL时
node = node->right;//本规则是取药删除节点的右子树中最小的节点
while ((left = node->left) != NULL) {
node = left;
}
//找到右子树中的最小节点，并取其右孩子赋值给child
child = node->right;
parent = node->parent;//获取最小节点的父节点
color = node->color; //获取最小节点的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;
}
rb_node_t * rb_erase(const key_type key, rb_node_t *root)
{
rb_node_t *old,*child,*parent,*left,*node;
COLOR color;
if ( !(node = rb_search_auxiliary(root,key,NULL)))
{
fprintf(stderr,"Cannot find node U want to delete");
return root;
}
old = node;
//删除的节点有双非空节点
if ( node->left && node->left )
{
//使用该节点右子数的最小元素取代待删除元素
node = node->right;
while( (left = node->left) )
{
node = 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_balance(child,parent,root);
}
return root;
}
rb_node_t *rb_search(key_t key, rb_node_t *root)
{
return rb_search_auxiliary(key, root, NULL);
}
RBTreeNode* RBTree_Search( RBTree* rbt, int key )
{
return rb_search_auxiliary( rbt->root, key, NULL, rbt->compare, NULL );
}
static rb_node_t*
rb_search( rb_node_t* root, mem_data_t *data, rb_data_type_t type )
{
return rb_search_auxiliary(root, data, type, NULL);
}
rb_node_t * rb_search(rb_node_t *root, key_type key)
{
return rb_search_auxiliary(root,key,NULL);
}
/** 删除红黑树中的结点 */
static int
rb_erase( rb_tree_t *rbt, mem_data_t *data, rb_data_type_t type )
{
rb_color_t color;
rb_node_t *root, *child, *parent, *old, *left, *node;
root = rbt->root;
/* 查找要删除的结点 */
node = rb_search_auxiliary( root, data, type, NULL );
if( !node ) {
return -1;
}
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 );
}
rbt->root = root;
rbt->total_node -= 1;
return 0;
}
//六、红黑树的删除
//------------------------------------------------------------
//红黑树的删除结点
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))){//调用rb_search_auxiliary查找要删除的结点
printf("key %d is not exist!/n", key);
return root;
}
old = node;
if(node->left && node->right){
node = node->right;
while(left = node->left){
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);
//调用rb_erase_rebalance来恢复红黑树性质
}
return root;
}
