红黑树(red black tree)的实现

以前看过几次红黑树的介绍，但是一直感觉云里雾里的，不是很明白，什么LL旋转、RR旋转之类的，分类讨论也不是很清晰，前几天偶然网上碰到一本电子书：[麻省理工学院-算法导论].Introduction.to.Algorithms，看过后感觉豁然开朗，书中描述的比较清楚，看过后代码的实现很简单。

关于红黑树的介绍，cnblog的abatei老兄的文章写得比较详细，详情请点击这里

关于红黑树的查找就不用说了(就是二叉树的查找)，这里主要说一下插入和删除。

红黑树其实就是特殊的二叉树，要满足一下五个条件：

1、 每个结点的颜色只能是红色或黑色。

2、 根结点是黑色的。

3、 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵）

4、 如果一个结点是红的，则它的两个儿子都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。

5、 对于每个结点来说，从该结点到其子孙叶结点的所有路径上包含相同数目的黑结点。

插入：插入主要分为两个步骤，首先就是简单的二叉树的插入，然后就是红黑树的调整。

每次经过第一步骤插入新元素后，首先将此节点的颜色置为红色，然后调整红黑树，大体分为两种：当前插入的节点的父节点是其祖父节点的左节点或者右节点(其实说白了就是一种，因为左、右是对称的)；而每种又有三种情形，下面只讨论当前插入的节点色父节点是左子节点的情况，因为右是对称的：

1. 当前节点的父节点的兄弟节点的颜色为红色：将当前节点的父节点和父节点的兄弟节点都置为黑色，并将祖父节点置为红色，然后将当前节点指向祖父节点，继续

2. 当前节点为其父节点的右子节点：当前节点指向其父节点，然后以当前节点为顶点进行左旋转

3. 当前节点为其父节点的左子节点：当前节点的父节点置为黑色，祖父节点置为红色，然后以祖父节点为顶点进行右旋转

每种情况的解决都要确保不影响当前节点的子树满足红黑树的5个性质。

删除：删除也是两个步骤，简单的二叉树的删除以及红黑树的调整，但是比插入复杂多了

只有在删除黑色节点的情况下才需要调整红黑树，而删除红色节点并不会破坏红黑树的结构

由于左右的对称性，这里只讨论左边的情况：

1. 当前节点的兄弟节点为红色节点

2. 当前节点的兄弟节点的子节点都为黑色

3. 当前节点的兄弟节点的右子节点为黑色

4. 当前节点的兄弟节点的左子节点为黑色

具体实现请参照下面的代码，我就不再赘述了^_^

具体代码如下：

rbtree.h

#ifndef NEWSENTRY_REDBLACK_TREE_H
#define NEWSENTRY_REDBLACK_TREE_H

/*
* A binary search tree is a red-black tree if it satisfies the following red-black properties:
* 1. Every node is either red or black.
* 2. The root is black.
* 3. Every leaf (NIL) is black.
* 4. If a node is red, then both its children are black.
* 5. For each node, all paths from the node to descendant leaves contain the same number of black nodes.
*
*/

/*
* self-defined typedefs
* You can change the typedefs to their own types
* but remember that this implementation of red black tree
* does not use deep copy, so if KeyType is something about
* string, you have to maintain the memory on your own!
*
* */
typedef const char * KeyType;
typedef int ValueType;
typedef void * rbt_handle_t;
typedef enum { false, true } bool;

/*
* Function pointer to compare keys
* return 0 if they are equal
* negative if the first one is less than the second
* positive otherwise
*
* */
typedef int (*pfn_cmp)(KeyType, KeyType);

typedef enum {
RBT_SUCCESS, 				/* suceessful */
RBT_RBTREE_IS_NULL, 		/* red black tree is NULL */
RBT_RBTREE_IS_EMPTY, 		/* red black tree is empty */
RBT_OUT_OF_MEMORY, 		/* alloc memory failed: out of memory */
RBT_KEY_EXISTED, 			/* the key has existed, only used in inserting */
RBT_KEY_NONE_EXISTED		/* the key doesnot exist, only meaningful in removing method */
} RbtStatus;

/*
* Create red black tree
* user can define their own cmp function
* but the function must be compatible with pfn_cmp
*
* */
rbt_handle_t create_red_black_tree(pfn_cmp cmp);
void release_red_black_tree(rbt_handle_t root);

/*
* Insert the key and value to red black tree
* Only RBT_SUCCESS (which is 0) implies success, others mean failure
* refer to above enum to know the detailed information about failure
*
* @tree:		handle to red black tree
* @key:		keyword on which sorting is based on
* @value:		real data stored
*
* */
RbtStatus rbt_insert(rbt_handle_t tree, KeyType key, ValueType value);
RbtStatus rbt_find(rbt_handle_t tree, KeyType key);

/*
* Remove the node with key as keyword from red black tree
* Only RBT_SUCCESS (which is 0) implies success, others mean failure
* refer to above enum type to know the detailed information about failure
*
* @tree:		handle to red black tree
* @key:		keyword
* @value:		store the keyword's corresponding value if succeeded, otherwise undefined
*
* */
RbtStatus rbt_remove(rbt_handle_t tree, KeyType key, ValueType * value);

/* Check whether the red black tree is valid
* i.e. make sure there is not violation of the 5 properties */
bool rbt_is_valid(rbt_handle_t tree);

#endif

rbtree.c

//#include <stdio.h>
#include <stdlib.h>
//#include <string.h>

#include "rbtree.h"

/*
* A binary search tree is a red-black tree if it satisfies the following red-black properties:
* 1. Every node is either red or black.
* 2. The root is black.
* 3. Every leaf (NIL) is black.
* 4. If a node is red, then both its children are black.
* 5. For each node, all paths from the node to descendant leaves contain the same number of black nodes.
*
*/

typedef enum { RED, BLACK } ColorType;

typedef struct rbt_node
{
struct rbt_node * father_;
struct rbt_node * left_;
struct rbt_node * right_;
ColorType color_;
KeyType key_;
ValueType value_;
} rbt_node_t;

typedef struct red_black_tree
{
rbt_node_t * root_;
pfn_cmp cmp_;
} red_black_tree_t;

/* Sentinel node, all leaves's children are set to Sentinel */
static rbt_node_t Sentinel = { NULL, &Sentinel, &Sentinel, BLACK, (KeyType)0, (ValueType)0 };
static rbt_node_t * nil_ = &Sentinel;

int default_compare(KeyType a, KeyType b);

rbt_node_t * create_rbt_node(KeyType key, ValueType value);

/* auxiliary functions to manipulate red-black-tree */
rbt_node_t * auxiliary_rbt_find(rbt_node_t * root, KeyType key, pfn_cmp cmp);
rbt_node_t * auxiliary_rbt_insert(rbt_node_t * root, rbt_node_t * node, pfn_cmp cmp);
rbt_node_t * auxiliary_rbt_remove(rbt_node_t * tree, rbt_node_t * node, pfn_cmp cmp);
rbt_node_t * auxiliary_rbt_insert_fixup(rbt_node_t * root, rbt_node_t * node);
rbt_node_t* auxiliary_rbt_remove_fixup(rbt_node_t * root, rbt_node_t * node);
rbt_node_t * auxiliary_rbt_rotate_left(rbt_node_t * root, rbt_node_t * node);
rbt_node_t * auxiliary_rbt_rotate_right(rbt_node_t * root, rbt_node_t * node);
void auxiliary_release_red_black_tree(rbt_node_t * root);
int auxiliary_validator(rbt_node_t * root);

int default_compare(KeyType a, KeyType b)
{
return (a - b);
}

/* implementations of functions' */
static pfn_cmp default_cmp = &default_compare;
rbt_handle_t create_red_black_tree(pfn_cmp compare)
{
red_black_tree_t * tree;
if (!compare)
compare = default_cmp;
tree = (red_black_tree_t *)malloc(sizeof(red_black_tree_t));
if (!tree)
return NULL;
tree->root_ = nil_;
tree->cmp_ = compare;

return (rbt_handle_t)tree;
}

void release_red_black_tree(rbt_handle_t root)
{
red_black_tree_t * tree = (red_black_tree_t *)root;
if (tree)
{
auxiliary_release_red_black_tree(tree->root_);
free(tree);
}
}

bool rbt_is_valid(rbt_handle_t rbtree)
{
red_black_tree_t * tree = (red_black_tree_t *)rbtree;
if (!tree)
return false;
return (auxiliary_validator(tree->root_) >= 0);
}

RbtStatus rbt_find(rbt_handle_t rbtree, KeyType key)
{
red_black_tree_t * tree = (red_black_tree_t *)rbtree;
if (!tree)
return RBT_RBTREE_IS_NULL;
if (auxiliary_rbt_find(tree->root_, key, tree->cmp_) != nil_)
return RBT_SUCCESS;
else
return RBT_KEY_NONE_EXISTED;
}

RbtStatus rbt_insert(rbt_handle_t rbtree, KeyType key, ValueType value)
{
red_black_tree_t * tree = (red_black_tree_t *)rbtree;
rbt_node_t * node, * p;
if (!tree)
return RBT_RBTREE_IS_NULL;
node = create_rbt_node(key, value);
if (node == nil_)
return RBT_OUT_OF_MEMORY;

if (tree->root_ == nil_)
{
tree->root_ = node;
return RBT_SUCCESS;
}
p = auxiliary_rbt_insert(tree->root_, node, tree->cmp_);
if (p != node)
{
free(node);
return RBT_KEY_EXISTED;
}
node->color_ = RED;
tree->root_ = auxiliary_rbt_insert_fixup(tree->root_, node);

return RBT_SUCCESS;
}

RbtStatus rbt_remove(rbt_handle_t rbtree, KeyType key, ValueType * value)
{
red_black_tree_t * tree = (red_black_tree_t *)rbtree;
rbt_node_t * node;

if (!tree)
return RBT_RBTREE_IS_NULL;

if (tree->root_ == nil_)
return RBT_KEY_NONE_EXISTED;
node = auxiliary_rbt_find(tree->root_, key, tree->cmp_);
if (node == nil_)
return RBT_KEY_NONE_EXISTED;
tree->root_ = auxiliary_rbt_remove(tree->root_, node, tree->cmp_);

if (value)
* value = node->value_;

return RBT_SUCCESS;
}

rbt_node_t * create_rbt_node(KeyType key, ValueType value)
{
rbt_node_t * node = (rbt_node_t *)malloc(sizeof(rbt_node_t));
if (node)
{
node->father_ = nil_;
node->left_ = nil_;
node->right_ = nil_;
node->color_ = BLACK;
node->key_ = key;
node->value_ = value;
}
return node;
}

void auxiliary_release_red_black_tree(rbt_node_t * root)
{
if (root == nil_)
return;
auxiliary_release_red_black_tree(root->left_);
auxiliary_release_red_black_tree(root->right_);
free(root);
}

int auxiliary_validator(rbt_node_t * root)
{
int ldepth, rdepth;

if (root == nil_)
return 0;
ldepth = auxiliary_validator(root->left_);
rdepth = auxiliary_validator(root->right_);

if (ldepth < 0 || rdepth < 0)
return -1;

if (ldepth != rdepth)
{
printf( "/n/tViolation found! key: %s, color: %s",
root->key_, (root->color_ == RED)? "red": "black");
return -1;
}

if (root->color_ == BLACK)
return (ldepth + 1);
return ldepth;
}

rbt_node_t * auxiliary_rbt_find(rbt_node_t * root, KeyType key, pfn_cmp cmp)
{
int ret;

if (root == nil_)
return nil_;
ret = cmp(root->key_, key);
if (ret == 0)
return root;
else if (ret < 0)
return auxiliary_rbt_find(root->right_, key, cmp);
else
return auxiliary_rbt_find(root->left_, key, cmp);
}

rbt_node_t * auxiliary_rbt_rotate_left(rbt_node_t * root, rbt_node_t * node)
{
rbt_node_t * p;
if (!node || !root || root == nil_ || node == nil_)
return root;

p = node->right_;
if (p == nil_)
return root;

node->right_ = p->left_;
if (p->left_ != nil_)
p->left_->father_ = node;
p->father_ = node->father_;

if (node->father_ == nil_)
root = p;
else if (node->father_ != nil_)
{
if (node == node->father_->left_)
node->father_->left_ = p;
else
node->father_->right_ = p;
}

p->left_ = node;
node->father_ = p;

return root;
}

/* rotate right
*
*
*
*
*
* */
rbt_node_t * auxiliary_rbt_rotate_right(rbt_node_t * root, rbt_node_t * node)
{
rbt_node_t * p;

if (!node || !root || node == nil_ || root == nil_)
return root;

p = node->left_;
if (p == nil_)
return root;

node->left_ = p->right_;
if (p->right_ != nil_)
p->right_->father_ = node;
p->father_ = node->father_;

if (node->father_ == nil_)
root = p;
else if (node->father_ != nil_)
{
if (node == node->father_->left_)
node->father_->left_ = p;
else
node->father_->right_ = p;
}

p->right_ = node;
node->father_ = p;

return root;
}

/* Adjust the tree after inserting a red node so that it will satisify the 5 property of red black tree */
rbt_node_t * auxiliary_rbt_insert_fixup(rbt_node_t * root, rbt_node_t * node)
{
rbt_node_t * uncle;

if (root == nil_ || node == nil_)
return root;

uncle = nil_;
while (node != root && node->father_->color_ == RED) /* violate property 4 */
{
/*
* Firstly, determine current node's father is its grandfather's left son or right son,
* in each circumstance there existed 3 cases:
* 1. current node's father's sibling is a red node
* 2. current node is its father's left or right son
* 3. current node is rule 2's sibling
*
* */
if (node->father_ == node->father_->father_->left_)
{
uncle = node->father_->father_->right_;
if (uncle->color_ == RED)
{
/*
* case 1:
* If its father's sibling (i.e. uncle) is a red node
* then set its father and uncle's color to black
* and set its grandfather's color to red
* thus maintaining property 5 and solve the violation of property 4
*
* */
uncle->color_ = BLACK;
node->father_->color_ = BLACK;
node->father_->father_->color_ = RED;
node = node->father_->father_;
}else{
/*
* case 2:
* If it is its father's right son
* change current node to its father and rotate left
* while preserving property 5
*
* */
if (node == node->father_->right_)
{
node = node->father_;
root = auxiliary_rbt_rotate_left(root, node);
}
/*
* case 3:
* Otherwise, color its father with black and grandfather with red
* and then rotate right
*
* */
node->father_->father_->color_ = RED;
node->father_->color_ = BLACK;
root = auxiliary_rbt_rotate_right(root, node->father_->father_);
}
}else{
/*
* In this circumstance, the situation is
* same as above clause, so just exchange
* above clause's left and right
*
* */
uncle = node->father_->father_->left_;
if (uncle->color_ == RED)
{
uncle->color_ = BLACK;
node->father_->color_ = BLACK;
node->father_->father_->color_ = RED;
node = node->father_->father_;
}else{
if (node == node->father_->left_)
{
node = node->father_;
root = auxiliary_rbt_rotate_right(root, node);
}
node->father_->father_->color_ = RED;
node->father_->color_ = BLACK;
root = auxiliary_rbt_rotate_left(root, node->father_->father_);
}
}
}

root->color_ = BLACK;
return root;
}

rbt_node_t * auxiliary_rbt_insert(rbt_node_t * root, rbt_node_t * node, pfn_cmp cmp)
{
int ret;

if (!root || !node || node == nil_)
return root;

ret = cmp(root->key_, node->key_);
if (ret == 0)
return root;
else if (ret < 0)
{
if (root->right_ == nil_)
{
root->right_ = node;
node->father_ = root;
}
else
return auxiliary_rbt_insert(root->right_, node, cmp);
}else{
if (root->left_ == nil_)
{
root->left_ = node;
node->father_ = root;
}
else
return auxiliary_rbt_insert(root->left_, node, cmp);
}

return node;
}

rbt_node_t * auxiliary_rbt_remove(rbt_node_t * root, rbt_node_t * node, pfn_cmp cmp)
{
rbt_node_t * child = nil_;
rbt_node_t * parent = nil_;
rbt_node_t * old = node;

if (!root || root == nil_ || !node || node == nil_)
return root;

if (node->left_ == nil_)
child = node->right_;
else if (node->right_ == nil_)
child = node->left_;
else
{
node = node->right_;
while (node->left_ != nil_) /* find the leftmost node */
node = node->left_;
child = node->right_;
}
//if (child != nil_)
child->father_ = node->father_;

if (nil_ == node->father_)
root = child;
else
{
if (node->father_->left_ == node)
node->father_->left_ = child;
else
node->father_->right_ = child;
}

if (old != node)
{
KeyType ktmp;
ValueType vtmp;

ktmp = old->key_;
old->key_ = node->key_;
node->key_ = ktmp;

vtmp = old->value_;
old->value_ = node->value_;
node->value_ = vtmp;
}

if (node->color_ == BLACK)
root = auxiliary_rbt_remove_fixup(root, child);

return root;
}

/*
* Adjust the tree after deleting a black node so that
* it will satisify the 5 property of red black tree
*
* */
rbt_node_t * auxiliary_rbt_remove_fixup(rbt_node_t * root, rbt_node_t * node)
{
rbt_node_t * sibling = nil_;

if (!root || !node || root == nil_)
return root;

while (node != root && node->color_ == BLACK)
{
/*
* Firstly determing current node is his father's
* left or right son, and in both circumstances,
* there exist 4 cases:
* 1. current node's sibling's color is red
* 2. current node's sibling's color is black and
*	its sibling's two son are both black
* 3. current node's sibling's right son is black
* 4. current node's sibling's left son is black
*
* After case 1, the situation will convert to case 2, 3, 4
* only case 2 will continue to loop
*
* whatever the case is, make sure current's node's descendant's MUST
* satisfy the 5 properties of red black tree
*
* */
if (node == node->father_->left_)
{
sibling = node->father_->right_;
if (sibling->color_ == RED)
{
/*
* case 1:
* Set sibling's color to black and father to red
* and then rotate left, thus converting case 1
* to following case 2, 3 or 4
*
* */
sibling->color_ = BLACK;
node->father_->color_ = RED;
root = auxiliary_rbt_rotate_left(root, node->father_);
sibling = node->father_->right_;
}
if (sibling->left_->color_ == BLACK && sibling->right_->color_ == BLACK)
{
/*
* case 2:
* sibling's two sons are black so change sibling's color
* to red and move current node upward so as to loop
*
* */
sibling->color_ = RED;
node = node->father_;
} else{
/*
* case 3:
* Set sibling's left son to black and sibling to red
* then rotate right while preserving property 5
*
* */
if (sibling->right_->color_ == BLACK)
{
sibling->left_->color_ = BLACK;
sibling->color_ = RED;
root = auxiliary_rbt_rotate_right(root, sibling);
sibling = node->father_->right_;
}
/*
* case 4:
* sibling inherit node's father's color, then set node's father
* and sibling's right son to black, secondly rotate right
* in the end set node to root and terminate the loop
*
* */
sibling->color_ = node->father_->color_;
node->father_->color_ = BLACK;
sibling->right_->color_ = BLACK;
root = auxiliary_rbt_rotate_left(root, node->father_);
node = root;
}
}else{
/*
* In this circumstance, the situation is
* same as above clause, so just exchange
* above clause's left and right
*
* */
sibling = node->father_->left_;
if (sibling->color_ == RED)
{
sibling->color_ = BLACK;
node->father_->color_ = RED;
root = auxiliary_rbt_rotate_right(root, node->father_);
sibling = node->father_->left_;
}
if (sibling->left_->color_ == BLACK && sibling->right_->color_ == BLACK)
{
sibling->color_ = RED;
node = node->father_;
}else{
if (sibling->left_->color_ == BLACK)
{
sibling->right_->color_ = BLACK;
sibling->color_ = RED;
root = auxiliary_rbt_rotate_left(root, sibling);
sibling = node->father_->left_;
}
sibling->color_ = node->father_->color_;
node->father_->color_ = BLACK;
sibling->left_->color_ = BLACK;
root = auxiliary_rbt_rotate_right(root, node->father_);
node = root;
}
}
}
node->color_ = BLACK;
return root;
}