myrbtree.c

sourceforge历史版本完整下载: http://sourceforge.net/project/showfiles.php?group_id=202044 提供了基于b树索引算法的文件数据数据

/*
* 
* myrbtree.c 2007-3-28 23:02:55 红黑树
*
* author:lin shao chuan (email:[e-mail], msn:[e-mail])
*
*/

/*
//红黑树
//         红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，
他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，
但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。
//
//红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，
因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，
这些修改提供了更好的性能，以及对set操作的支持)。 
//
//
//背景和术语
//
//        红黑树是一种特定类型的二叉树，它是在计算机科学中用来组织数据比如数字的块的一种结构。所有数据块都存储在节点中。
这些节点中的某一个节点总是担当启始位置的功能，它不是任何节点的儿子；我们称之为根节点或根。它有最多两个"儿子"，
都是它连接到的其他节点。所有这些儿子都可以有自己的儿子，以此类推。这样根节点就有了把它连接到在树中任何其他节点的路径。
//
//        如果一个节点没有儿子，我们称之为叶子节点，因为在直觉上它是在树的边缘上。子树是从特定节点可以延伸到的树的某一部分，其自身被当作一个树。
在红黑树中，叶子被假定为 null 或空。
//
//        由于红黑树也是二叉查找树，它们当中每一个节点都的比较值都必须大于或等于在它的左子树中的所有节点，并且小于或等于在它的右子树中的所有节点。
这确保红黑树运作时能够快速的在树中查找给定的值。
//
//用途和好处
//
//        红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可能的最坏情况担保。
这不只是使它们在时间敏感的应用如即时应用(real time application)中有价值，
而且使它们有在提供最坏情况担保的其他数据结构中作为建造板块的价值；例如，在计算几何中使用的很多数据结构都可以基于红黑树。
//
//        红黑树在函数式编程中也特别有用，在这里它们是最常用的持久数据结构之一，它们用来构造关联数组和集合，
在突变之后它们能保持为以前的版本。除了O(log n)的时间之外，红黑树的持久版本对每次插入或删除需要O(log n)的空间。
//
//        红黑树是 2-3-4树的一种等同。换句话说，对于每个 2-3-4 树，都存在至少一个数据元素是同样次序的红黑树。
在 2-3-4 树上的插入和删除操作也等同于在红黑树中颜色翻转和旋转。这使得 2-3-4 树成为理解红黑树背后的逻辑的重要工具，
这也是很多介绍算法的教科书在红黑树之前介绍 2-3-4 树的原因，尽管 2-3-4 树在实践中不经常使用。
//
//属性
//
//        红黑树是每个节点都有颜色特性的二叉查找树，颜色的值是红色或黑色之一。除了二叉查找树带有的一般要求，
我们对任何有效的红黑树加以如下增补要求:
//
//        1.节点是红色或黑色。 
//
//        2.根是黑色。 
//
//        3.所有叶子（外部节点）都是黑色。 
//
//        4.每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 
//
//        5.从每个叶子到根的所有路径都包含相同数目的黑色节点。 
//
//        这些约束强制了红黑树的关键属性: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。
因为操作比如插入、删除和查找某个值都要求与树的高度成比例的最坏情况时间，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，
而不同于普通的二叉查找树。
//
//        要知道为什么这些特性确保了这个结果，注意到属性4导致了路径不能有两个毗连的红色节点就足够了。
最短的可能路径都是黑色节点，最长的可能路径有交替的红色和黑色节点。因为根据属性5所有最长的路径都有相同数目的黑色节点，
这就表明了没有路径能多于任何其他路径的两倍长。
//
//        在很多树数据结构的表示中，一个节点有可能只有一个儿子，而叶子节点包含数据。用这种范例表示红黑树是可能的，
但是这会改变一些属性并使算法复杂。为此，本文中我们使用 "nil 叶子" 或"空(null)叶子"，如上图所示，它不包含数据而只充当树在此结束的指示。
这些节点在绘图中经常被省略，导致了这些树好象同上述原则相矛盾，而实际上不是这样。与此有关的结论是所有节点都有两个儿子，
尽管其中的一个或两个可能是空叶子。
//
//操作
//
//        在红黑树上只读操作不需要对用于二叉查找树的操作做出修改，因为它也二叉查找树。
但是，在插入和删除之后，红黑属性可能变得违规。
恢复红黑属性需要少量(O(log n))的颜色变更(这在实践中是非常快速的)并且不超过三次树旋转(对于插入是两次)。
这允许插入和删除保持为 O(log n) 次，但是它导致了非常复杂的操作。 
*/

#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:新节点的父节点