头文件:
#ifndef __AOS_RBTREE_H__
#define __AOS_RBTREE_H__
typedef enum aos_rbcolor_t
{
AOS_RBCOLOR_BLACK,
AOS_RBCOLOR_RED
} AOS_RBCOLOR_T;
/**
* The type of the node of the R/B Tree.
*/
typedef struct aos_rbtree_node
{
/** Pointers to the node's parent, and left and right siblings. */
struct aos_rbtree_node *parent, *left, *right;
/** Key associated with the node. */
const VOID *key;
/** User data associated with the node. */
VOID *user_data;
/** The R/B Tree node color. */
AOS_RBCOLOR_T color;
} AOS_RBTREE_NODE_T;
/**
* The type of function use to compare key value of tree node.
* @return
* 0 if the keys are equal
* <0 if key1 is lower than key2
* >0 if key1 is greater than key2.
*/
typedef S32 aos_rbtree_comp(const VOID *key1, const VOID *key2);
/**
* Declaration of a red-black tree. All elements in the tree must have UNIQUE
* key.
* A red black tree always maintains the balance of the tree, so that the
* tree height will not be greater than lg(N). Insert, search, and delete
* operation will take lg(N) on the worst case. But for insert and delete,
* there is additional time needed to maintain the balance of the tree.
*/
typedef struct aos_rbtree_t
{
AOS_RBTREE_NODE_T null_node; /**< Constant to indicate NULL node. */
AOS_RBTREE_NODE_T *null; /**< Constant to indicate NULL node. */
AOS_RBTREE_NODE_T *root; /**< Root tree node. */
U32 size; /**< Number of elements in the tree. */
aos_rbtree_comp *comp; /**< Key comparison function. */
} AOS_RBTREE_T;
/**
* Guidance on how much memory required for each of the node.
*/
#define AOS_RBTREE_NODE_SIZE (sizeof(AOS_RBTREE_NODE_T))
/**
* Guidance on memory required for the tree.
*/
#define AOS_RBTREE_SIZE (sizeof(AOS_RBTREE_T))
VOID aos_rbtree_init( AOS_RBTREE_T *tree, aos_rbtree_comp *comp);
AOS_RBTREE_NODE_T* aos_rbtree_first( AOS_RBTREE_T *tree );
AOS_RBTREE_NODE_T* aos_rbtree_last( AOS_RBTREE_T *tree );
AOS_RBTREE_NODE_T* aos_rbtree_next( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
AOS_RBTREE_NODE_T* aos_rbtree_prev( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
S32 aos_rbtree_insert( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
AOS_RBTREE_NODE_T* aos_rbtree_find( AOS_RBTREE_T *tree,
const VOID *key );
AOS_RBTREE_NODE_T* aos_rbtree_erase( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
U32 aos_rbtree_max_height( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
U32 aos_rbtree_min_height( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node );
#endif /* __PJ_RBTREE_H__ */实现文件:
#include "syscfg.h"
#include "aos.h"
static VOID left_rotate( AOS_RBTREE_T *tree, AOS_RBTREE_NODE_T *node )
{
AOS_RBTREE_NODE_T *rnode, *parent;
rnode = node->right;
if (rnode == tree->null)
return;
node->right = rnode->left;
if (rnode->left != tree->null)
rnode->left->parent = node;
parent = node->parent;
rnode->parent = parent;
if (parent != tree->null)
{
if (parent->left == node)
parent->left = rnode;
else
parent->right = rnode;
}
else
{
tree->root = rnode;
}
rnode->left = node;
node->parent = rnode;
}
static VOID right_rotate( AOS_RBTREE_T *tree, AOS_RBTREE_NODE_T *node )
{
AOS_RBTREE_NODE_T *lnode, *parent;
lnode = node->left;
if (lnode == tree->null)
return;
node->left = lnode->right;
if (lnode->right != tree->null)
lnode->right->parent = node;
parent = node->parent;
lnode->parent = parent;
if (parent != tree->null)
{
if (parent->left == node)
parent->left = lnode;
else
parent->right = lnode;
}
else
{
tree->root = lnode;
}
lnode->right = node;
node->parent = lnode;
}
static VOID insert_fixup( AOS_RBTREE_T *tree, AOS_RBTREE_NODE_T *node )
{
AOS_RBTREE_NODE_T *temp, *parent;
while (node != tree->root && node->parent->color == AOS_RBCOLOR_RED)
{
parent = node->parent;
if (parent == parent->parent->left)
{
temp = parent->parent->right;
if (temp->color == AOS_RBCOLOR_RED)
{
temp->color = AOS_RBCOLOR_BLACK;
node = parent;
node->color = AOS_RBCOLOR_BLACK;
node = node->parent;
node->color = AOS_RBCOLOR_RED;
}
else
{
if (node == parent->right)
{
node = parent;
left_rotate(tree, node);
}
temp = node->parent;
temp->color = AOS_RBCOLOR_BLACK;
temp = temp->parent;
temp->color = AOS_RBCOLOR_RED;
right_rotate( tree, temp);
}
}
else
{
temp = parent->parent->left;
if (temp->color == AOS_RBCOLOR_RED)
{
temp->color = AOS_RBCOLOR_BLACK;
node = parent;
node->color = AOS_RBCOLOR_BLACK;
node = node->parent;
node->color = AOS_RBCOLOR_RED;
}
else
{
if (node == parent->left)
{
node = parent;
right_rotate(tree, node);
}
temp = node->parent;
temp->color = AOS_RBCOLOR_BLACK;
temp = temp->parent;
temp->color = AOS_RBCOLOR_RED;
left_rotate(tree, temp);
}
}
}
tree->root->color = AOS_RBCOLOR_BLACK;
}
static VOID delete_fixup( AOS_RBTREE_T *tree, AOS_RBTREE_NODE_T *node )
{
AOS_RBTREE_NODE_T *temp;
while (node != tree->root && node->color == AOS_RBCOLOR_BLACK)
{
if (node->parent->left == node)
{
temp = node->parent->right;
if (temp->color == AOS_RBCOLOR_RED)
{
temp->color = AOS_RBCOLOR_BLACK;
node->parent->color = AOS_RBCOLOR_RED;
left_rotate(tree, node->parent);
temp = node->parent->right;
}
if (temp->left->color == AOS_RBCOLOR_BLACK &&
temp->right->color == AOS_RBCOLOR_BLACK)
{
temp->color = AOS_RBCOLOR_RED;
node = node->parent;
}
else
{
if (temp->right->color == AOS_RBCOLOR_BLACK)
{
temp->left->color = AOS_RBCOLOR_BLACK;
temp->color = AOS_RBCOLOR_RED;
right_rotate( tree, temp);
temp = node->parent->right;
}
temp->color = node->parent->color;
temp->right->color = AOS_RBCOLOR_BLACK;
node->parent->color = AOS_RBCOLOR_BLACK;
left_rotate(tree, node->parent);
node = tree->root;
}
}
else
{
temp = node->parent->left;
if (temp->color == AOS_RBCOLOR_RED)
{
temp->color = AOS_RBCOLOR_BLACK;
node->parent->color = AOS_RBCOLOR_RED;
right_rotate( tree, node->parent);
temp = node->parent->left;
}
if (temp->right->color == AOS_RBCOLOR_BLACK &&
temp->left->color == AOS_RBCOLOR_BLACK)
{
temp->color = AOS_RBCOLOR_RED;
node = node->parent;
}
else
{
if (temp->left->color == AOS_RBCOLOR_BLACK)
{
temp->right->color = AOS_RBCOLOR_BLACK;
temp->color = AOS_RBCOLOR_RED;
left_rotate( tree, temp);
temp = node->parent->left;
}
temp->color = node->parent->color;
node->parent->color = AOS_RBCOLOR_BLACK;
temp->left->color = AOS_RBCOLOR_BLACK;
right_rotate(tree, node->parent);
node = tree->root;
}
}
}
node->color = AOS_RBCOLOR_BLACK;
}
VOID aos_rbtree_init( AOS_RBTREE_T *tree, aos_rbtree_comp *comp )
{
tree->null = tree->root = &tree->null_node;
tree->null->key = NULL;
tree->null->user_data = NULL;
tree->size = 0;
tree->null->left = tree->null->right = tree->null->parent = tree->null;
tree->null->color = AOS_RBCOLOR_BLACK;
tree->comp = comp;
}
AOS_RBTREE_NODE_T* aos_rbtree_first( AOS_RBTREE_T *tree )
{
register AOS_RBTREE_NODE_T *node = tree->root;
register AOS_RBTREE_NODE_T *null = tree->null;
while (node->left != null)
node = node->left;
return node != null ? node : NULL;
}
AOS_RBTREE_NODE_T* aos_rbtree_last( AOS_RBTREE_T *tree )
{
register AOS_RBTREE_NODE_T *node = tree->root;
register AOS_RBTREE_NODE_T *null = tree->null;
while (node->right != null)
node = node->right;
return node != null ? node : NULL;
}
AOS_RBTREE_NODE_T* aos_rbtree_next( AOS_RBTREE_T *tree,
register AOS_RBTREE_NODE_T *node )
{
register AOS_RBTREE_NODE_T *null = tree->null;
if (node->right != null)
{
for (node=node->right; node->left!=null; node = node->left)
/* VOID */;
}
else
{
register AOS_RBTREE_NODE_T *temp = node->parent;
while (temp!=null && temp->right==node)
{
node = temp;
temp = temp->parent;
}
node = temp;
}
return node != null ? node : NULL;
}
AOS_RBTREE_NODE_T* aos_rbtree_prev( AOS_RBTREE_T *tree,
register AOS_RBTREE_NODE_T *node )
{
register AOS_RBTREE_NODE_T *null = tree->null;
if (node->left != null)
{
for (node=node->left; node->right!=null; node=node->right)
/* VOID */;
}
else
{
register AOS_RBTREE_NODE_T *temp = node->parent;
while (temp!=null && temp->left==node)
{
node = temp;
temp = temp->parent;
}
node = temp;
}
return node != null ? node : NULL;
}
S32 aos_rbtree_insert( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *element )
{
S32 rv = 0;
AOS_RBTREE_NODE_T *node, *parent = tree->null,
*null = tree->null;
aos_rbtree_comp *comp = tree->comp;
node = tree->root;
while (node != null)
{
rv = (*comp)(element->key, node->key);
if (rv == 0)
{
/* found match, i.e. entry with equal key already exist */
return -1;
}
parent = node;
node = rv < 0 ? node->left : node->right;
}
element->color = AOS_RBCOLOR_RED;
element->left = element->right = null;
node = element;
if (parent != null)
{
node->parent = parent;
if (rv < 0)
parent->left = node;
else
parent->right = node;
insert_fixup( tree, node);
}
else
{
tree->root = node;
node->parent = null;
node->color = AOS_RBCOLOR_BLACK;
}
++tree->size;
return 0;
}
AOS_RBTREE_NODE_T* aos_rbtree_find( AOS_RBTREE_T *tree,
const VOID *key )
{
S32 rv;
AOS_RBTREE_NODE_T *node = tree->root;
AOS_RBTREE_NODE_T *null = tree->null;
aos_rbtree_comp *comp = tree->comp;
while (node != null)
{
rv = (*comp)(key, node->key);
if (rv == 0)
return node;
node = rv < 0 ? node->left : node->right;
}
return node != null ? node : NULL;
}
AOS_RBTREE_NODE_T* aos_rbtree_erase( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node )
{
AOS_RBTREE_NODE_T *succ;
AOS_RBTREE_NODE_T *null = tree->null;
AOS_RBTREE_NODE_T *child;
AOS_RBTREE_NODE_T *parent;
if (node->left == null || node->right == null)
{
succ = node;
}
else
{
for (succ=node->right; succ->left!=null; succ=succ->left)
/* VOID */;
}
child = succ->left != null ? succ->left : succ->right;
parent = succ->parent;
child->parent = parent;
if (parent != null)
{
if (parent->left == succ)
parent->left = child;
else
parent->right = child;
}
else
tree->root = child;
if (succ != node)
{
succ->parent = node->parent;
succ->left = node->left;
succ->right = node->right;
succ->color = node->color;
parent = node->parent;
if (parent != null)
{
if (parent->left==node)
parent->left=succ;
else
parent->right=succ;
}
if (node->left != null)
node->left->parent = succ;;
if (node->right != null)
node->right->parent = succ;
if (tree->root == node)
tree->root = succ;
}
if (succ->color == AOS_RBCOLOR_BLACK)
{
if (child != null)
delete_fixup(tree, child);
tree->null->color = AOS_RBCOLOR_BLACK;
}
--tree->size;
return node;
}
U32 aos_rbtree_max_height( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node )
{
U32 l, r;
if (node==NULL)
node = tree->root;
l = node->left != tree->null ? aos_rbtree_max_height(tree,node->left)+1 : 0;
r = node->right != tree->null ? aos_rbtree_max_height(tree,node->right)+1 : 0;
return l > r ? l : r;
}
U32 aos_rbtree_min_height( AOS_RBTREE_T *tree,
AOS_RBTREE_NODE_T *node )
{
U32 l, r;
if (node==NULL)
node=tree->root;
l = (node->left != tree->null) ? aos_rbtree_max_height(tree,node->left)+1 : 0;
r = (node->right != tree->null) ? aos_rbtree_max_height(tree,node->right)+1 : 0;
return l > r ? r : l;
}