自平衡linux红黑树
简介
实际应用中的自平衡搜索二叉树，除了AVL之外，红黑树也是备受宠爱。他不仅是linux中非线性结构的标准算法，而且是Java中TreeMap、TreeSet机制、C++中的STL这些经典工具背后的强大逻辑支撑。
与AVL不同，红黑树并不追求“绝对的平衡”，在毫无平衡性的BST和绝对平衡的AVL之间，红黑树聪明的做了折中，它的左右子树的高度差可以大于1，但任何一棵子树的高度不会大于另一棵兄弟子树高度的两倍。
正是红黑树放弃了AVL的绝对平衡的苛刻要求，让它获得了更加完美的性能表现。
复杂的逻辑并不意味着效率低，事实上红黑树的插入、删除、旋转、查找等操作都被控制在O（log2n）之中，对数级别的时间复杂度，使得红黑树尤其适用于数据无序程度高、数据量庞大且需要快速定位节点的场合。
AVL树是用树的高度差不大1这个绝对的条件来保证整棵树的平衡性的，而红黑树又是靠什么来保持二叉树的平衡性的？答案如下：
（1）树中的节点都是有颜色的，要么是红色，要么是黑色
（2）树的根节点是黑色的
（3）空节点的颜色算是黑色
（4）不能有连续的红色节点
（5）从任意一个节点开始到叶子的路径包含的黑色节点的个数相等
如果一棵二叉树满足以上条件，就会使得它不可能出现：一条路径的长度是另一条路径的两倍以上。
树的节点成员如下：
typedef struct _tree_node
{
tn_datatype data;
struct _tree_node *lchild; //左孩子指针
struct _tree_node *rchild; //右孩子指针
int height; //树的高度
struct _tree_node *parent; //指向父节点的指针
int color; //节点的颜色
#endif
对比AVL的节点设计，我们增加了树的父节点指针和颜色成员color，以及以该节点为根的子树的高度。
下面给出红黑树的算法实现。
算法实现
红黑树的公共操作文件rb_common.c，该文件主要提供旋转操作的接口，比如左旋、右旋、左右旋、右左旋，源代码如下：
rb_common.c
//////////////////////////////////////////////////////////////////
// Description: 红黑树的各种算法
//
//////////////////////////////////////////////////////////////////
#ifndef RB
#define RB
#endif
#include "drawtree.h"
#include "head4tree.h"
#include "head4rb.h"
// ================= 3，旋转操作 ================ //
void rb_rotate_left(linktree *proot, linktree n)
{
linktree gp = grandparent(n);
linktree p = n->parent;
p->rchild = n->lchild;
if(n->lchild != NULL)
n->lchild->parent = p;
n->lchild = p;
p->parent = n;
if(*proot == p)
*proot = n;
n->parent = gp;
if(gp != NULL)
{
if(p == gp->lchild)
gp->lchild = n;
else
gp->rchild = n;
}
}
void rb_rotate_right(linktree *proot, linktree n)
{
linktree gp = grandparent(n);
linktree p = n->parent;
p->lchild = n->rchild;
if(n->rchild != NULL)
n->rchild->parent = p;
n->rchild = p;
p->parent = n;
if(*proot == p)
*proot = n;
n->parent = gp;
if(gp != NULL)
{
if(p == gp->lchild)
gp->lchild = n;
else
gp->rchild = n;
}
}
void rb_rotate_leftright(linktree *proot, linktree n)
{
rb_rotate_left (proot, n);
rb_rotate_right(proot, n);
}
void rb_rotate_rightleft(linktree *proot, linktree n)
{
rb_rotate_right(proot, n);
rb_rotate_left (proot, n);
}
红黑树节点插入算法实现源码如下rb_insert.c：
//////////////////////////////////////////////////////////////////
// Description: 红黑树节点添加算法实现源码
//
//////////////////////////////////////////////////////////////////
#ifndef RB
#define RB
#endif
#include "drawtree.h"
#include "head4tree.h"
#include "head4rb.h"
void insert_fixup(linktree *proot, linktree new)
{
if(new->parent == NULL)
{
new->color = BLACK;
*proot = new;
return;
}
if(new->parent->color == BLACK) // 1: 黑父
return;
else
insert_case1(proot, new);
}
void insert_case1(linktree *proot, linktree new)
{
if(uncle(new) != NULL && uncle(new)->color == RED) // 2: 红父 + 红叔
{
new->parent->color = BLACK;
uncle(new)->color = BLACK;
grandparent(new)->color = RED;
insert_fixup(proot, grandparent(new));
}
else
insert_case2(proot, new);
}
void insert_case2(linktree *proot, linktree new) // 3: 红父 + 黑叔
{
if(new == new->parent->rchild &&
new->parent == grandparent(new)->lchild)
{
rb_rotate_left(proot, new);
new = new->lchild;
}
else if(new == new->parent->lchild &&
new->parent == grandparent(new)->rchild)
{
rb_rotate_right(proot, new);
new = new->rchild;
}
insert_case3(proot, new);
}
void insert_case3(linktree *proot, linktree new) // 3: 红父 + 黑叔
{
new->parent->color = BLACK;
grandparent(new)->color = RED;
if(new == new->parent->lchild &&
new->parent == grandparent(new)->lchild)
{
rb_rotate_right(proot, new->parent);
}
else
rb_rotate_left(proot, new->parent);
}
linktree bst_insert(linktree root, linktree new)
{
if(root == NULL)
return new;
new->parent = root;
if(new->data < root->data)
{
root->lchild = bst_insert(root->lchild, new);
}
else if(new->data > root->data)
{
root->rchild = bst_insert(root->rchild, new);
}
else
{
printf("%d exist.\n", new->data);
}
return root;
}
void rb_insert(linktree *proot, linktree new)
{
*proot = bst_insert(*proot, new);
insert_fixup(proot, new);
}
红黑树节点删除算法实现源码如下rb_delete.c：
//////////////////////////////////////////////////////////////////
// Description: 红黑树节点删除算法实现源码
//
//////////////////////////////////////////////////////////////////
#ifndef RB
#define RB
#endif
#include "drawtree.h"
#include "head4tree.h"
#include "head4rb.h"
linktree rb_find(linktree root, tn_datatype data)
{
if(root == NULL)
return NULL;
if(data < root->data)
return rb_find(root->lchild, data);
else if(data > root->data)
return rb_find(root->rchild, data);
return root;
}
void delete_fixup(linktree *proot, linktree new, linktree parent)
{
printf("%s\n", __FUNCTION__);
linktree ln, rn; // left nephew & right nephew
linktree s, gp; // sibling & grandparent
ln = rn = s = gp = NULL;
if(new == NULL && parent == NULL) // 原来的old是树都唯一节点
{
*proot = NULL;
return;
}
else if(new != NULL && parent == NULL) // 原来的old是根节点
{
*proot = new;
return;
}
else if(parent != NULL)
{
s = parent->lchild ? parent->lchild : parent->rchild;
gp = parent->parent;
if(s != NULL)
{
ln = s->lchild;
rn = s->rchild;
}
}
//1，红兄
if(Color(s) == RED)
{
if(new == parent->lchild)
{
rb_rotate_left(proot, s);
parent->color = RED;
s->color = BLACK;
delete_fixup(proot, new, parent);
}
if(new == parent->rchild)
{
rb_rotate_right(proot, s);
parent->color = RED;
s->color = BLACK;
delete_fixup(proot, new, parent);
}
}
//2，黑兄
if(Color(s) == BLACK)
{
//2.1，黑兄，二黑侄，红父
if(Color(parent) == RED &&
Color(ln) == BLACK &&
Color(rn) == BLACK)
{
parent->color = BLACK;
if(s != NULL)
s->color = RED;
return;
}
//2.2，黑兄，二黑侄，黑父
if(Color(parent) == BLACK &&
Color(ln) == BLACK &&
Color(rn) == BLACK)
{
if(s != NULL)
{
s->color = RED;
}
delete_fixup(proot, parent, parent->parent);
}
//2.3，黑兄，同边红侄（同为左孩子）
if(Color(ln) == RED && new == parent->lchild)
{
rb_rotate_right(proot, ln);
rb_rotate_left(proot, ln);
ln->color = parent->color;
parent->color = BLACK;
}
// (同为右孩子)
else if(Color(rn) == RED && new == parent->rchild)
{
rb_rotate_left(proot, rn);
rb_rotate_right(proot, rn);
rn->color = parent->color;
parent->color = BLACK;
}
// 对边红侄(左右)
else if(Color(ln) == RED && new == parent->rchild)
{
rb_rotate_right(proot, s);
s->color = parent->color;
parent->color = BLACK;
ln->color = BLACK;
}
// 对边红侄(右左)
else if(Color(rn) == RED && new == parent->lchild)
{
rb_rotate_left(proot, s);
s->color = parent->color;
parent->color = BLACK;
rn->color = BLACK;
}
}
}
void real_delete(linktree *proot, linktree old)
{
printf("%s\n", __FUNCTION__);
// old不可能为NULL，new可能为NULL
linktree new = old->lchild ? old->lchild : old->rchild;
linktree parent = old->parent;
if(old->parent != NULL)
{
if(old == old->parent->lchild)
old->parent->lchild = new;
else
old->parent->rchild = new;
old->parent = NULL;
}
if(new != NULL)
new->parent = old->parent;
if(Color(old) == BLACK && Color(new) == RED)
{
new->color = BLACK;
}
else if(Color(old) == BLACK && Color(new) == BLACK)
{
delete_fixup(proot, new, parent);
}
free(old);
}
void rb_delete(linktree *proot, tn_datatype data)
{
linktree tmp = rb_find(*proot, data);
if(tmp == NULL)
{
printf("%d is NOT exist.\n", data);
return;
}
linktree n = tmp;
if(tmp->lchild != NULL)
{
n = tmp->lchild;
for(;n->rchild != NULL; n = n->rchild);
tmp->data = n->data;
}
else if(tmp->rchild != NULL)
{
n = tmp->rchild;
for(;n->lchild != NULL; n = n->lchild);
tmp->data = n->data;
}
real_delete(proot, n); // n has ONE red-child at most
}
上述算法实现用到的头文件如下所示：
commonheader.h
#ifndef _COMMONHEADER_H_
#define _COMMONHEADER_H_
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <semaphore.h>
#include <fcntl.h>
#include <pthread.h>
#endif
head4queue.h
//////////////////////////////////////////////////////////////////
// Description: 本文件为队列核心头文件。
// 任何使用本队列算法的程序，在包含本头文件之前都需要
// 将如下宏定义成队列节点需要表达的数据类型：
//
// QUEUE_NODE_DATATYPE
//
// 否则队列的节点数据类型一律默认为 int
//////////////////////////////////////////////////////////////////
#ifndef _HEAD4QUEUE_H__
#define _HEAD4QUEUE_H__
#include "commonheader.h"
#ifndef QUEUE_NODE_DATATYPE
#define QUEUE_NODE_DATATYPE int
#endif
typedef QUEUE_NODE_DATATYPE qn_datatype;
struct _queue_node
{
qn_datatype data;
struct _queue_node *next;
};
typedef struct _queuenode
{
struct _queue_node *front;
struct _queue_node *rear;
#ifdef QUEUE_SIZE
int size;
#endif
}queuenode, *linkqueue;
bool is_empty_q(linkqueue);
bool out_queue(linkqueue, qn_datatype *);
bool en_queue(linkqueue, qn_datatype);
linkqueue init_queue(void);
#ifdef QUEUE_SIZE
int queue_size(linkqueue *);
#endif
#endif
head4rb.h
//////////////////////////////////////////////////////////////////
// Description: 红黑树的各种算法头文件
//
//////////////////////////////////////////////////////////////////
#ifndef _HEAD4RB_H_
#define _HEAD4RB_H_
#ifndef RB
#define RB
#endif
#include "head4tree.h"
static linktree grandparent(linktree n)
{
if(n == NULL || n->parent == NULL)
return NULL;
return n->parent->parent;
}
static linktree uncle(linktree n)
{
linktree gp = grandparent(n);
if(gp == NULL)
return NULL;
return n->parent == gp->lchild ?
gp->rchild : gp->lchild;
}
static linktree sibling(linktree n)
{
if(n == NULL || n->parent == NULL)
{
return NULL;
}
if(n == n->parent->lchild)
return n->parent->rchild;
else
return n->parent->lchild;
}
static linktree left_nephew(linktree n)
{
return sibling(n)==NULL ? NULL : sibling(n)->lchild;
}
static linktree right_nephew(linktree n)
{
return sibling(n)==NULL ? NULL : sibling(n)->rchild;
}
static int Color(linktree n)
{
return n==NULL ? BLACK : n->color;
}
void rotate_left(linktree *proot, linktree n);
void rotate_right(linktree *proot, linktree n);
linktree rb_find(linktree root, tn_datatype data);
linktree bst_insert(linktree root, linktree new);
void insert_case1(linktree *proot, linktree new);
void insert_case2(linktree *proot, linktree new);
void insert_case3(linktree *proot, linktree new);
void rb_insert(linktree *proot, linktree new);
void insert_fixup(linktree *proot, linktree new);
void rb_delete(linktree *proot, tn_datatype data);
void real_delete(linktree *proot, linktree old);
void delete_fixup(linktree *proot, linktree new, linktree parent);
#endif
head4tree.h
//////////////////////////////////////////////////////////////////
// Description: 本文件为二叉树核心头文件。
// 任何使用本二叉树结构算法的程序，在包含本头文件之前
// 都需要将如下宏定义成二叉树节点需要表达的数据类型：
//
// TREE_NODE_DATATYPE
//
// 否则二叉树的节点数据类型一律默认为 int
//////////////////////////////////////////////////////////////////
#ifndef _HEAD4TREE_H_
#define _HEAD4TREE_H_
/*
* Any application applying this linked-tree data structure should
* define the macro "TREE_NODE_DATATYPE" before include this head
* file, otherwise, the macro will be defined to 'int' as follow.
*
*/
#ifndef TREE_NODE_DATATYPE
#define TREE_NODE_DATATYPE int
#endif
#include "commonheader.h"
#define MAX(a, b) ({ \
typeof(a) _a = a; \
typeof(b) _b = b; \
(void)(&_a == &_b);\
_a > _b? _a : _b; \
})
typedef TREE_NODE_DATATYPE tn_datatype;
#ifdef RB
#define RED 0
#define BLACK 1
#endif
typedef struct _tree_node
{
tn_datatype data;
struct _tree_node *lchild;
struct _tree_node *rchild;
#ifdef AVL
int height;
#endif
#ifdef RB
struct _tree_node *parent;
int color;
#endif
}treenode, *linktree;
void pre_travel(linktree, void (*handler)(linktree));
void mid_travel(linktree, void (*handler)(linktree));
void post_travel(linktree, void (*handler)(linktree));
void level_travel(linktree, void (*handler)(linktree));
linktree bst_insert(linktree root, linktree new);
linktree bst_remove(linktree root, tn_datatype data);
linktree bst_find(linktree root, tn_datatype data);
#ifdef AVL
linktree avl_insert(linktree root, linktree new);
linktree avl_remove(linktree root, tn_datatype data);
linktree avl_rotate_left (linktree root);
linktree avl_rotate_right(linktree root);
linktree avl_rotate_leftright(linktree root);
linktree avl_rotate_rightleft(linktree root);
static int height(linktree root)
{
return root==NULL ? 0 : root->height;
}
#endif
static linktree new_node(tn_datatype data)
{
linktree new = malloc(sizeof(treenode));
if(new != NULL)
{
new->data = data;
new->lchild = NULL;
new->rchild = NULL;
#ifdef AVL
new->height = 1;
#endif
#ifdef RB
new->parent = NULL;
new->color = RED;
#endif
}
return new;
}
#endif
测试程序
设计一个程序，实现以下功能：
（1）输入大于0的数，则插入节点
（2）输入小于0的数，则删除节点
（3）输入0，则退出程序
（4）退出程序之前用网页画出该二叉树
示例代码如下：
rb_test.c
//////////////////////////////////////////////////////////////////
// Description: 使用红黑树操作接口实现的测试代码，测试结果用网页
// 展示。
//////////////////////////////////////////////////////////////////
#ifndef RB
#define RB
#endif
#include "drawtree.h"
#include "head4tree.h"
#include "head4rb.h"
int main(void)
{
linktree root = NULL;
printf("输入大于0的数插入节点\n");
printf("输入小于0的数删除节点\n");
printf("输入0退出程序\n");
int n;
while(1)
{
scanf("%d", &n);
if(n < 0)
{
rb_delete(&root, -n);
}
else if(n > 0)
{
linktree new = new_node(n);
rb_insert(&root, new);
}
else
break;
}
draw(root);
system("firefox *.html &");
return 0;
}
注意：上述测试程序使用了draw函数，用来在网页上画出二叉树，该函数相关的实现源码放在我的以下博文的drawtree.c文件中：
draw tree
运行效果如下所示：
输入大于0的数插入节点
输入小于0的数删除节点
输入0退出程序
1
2
3
4
5
9
12
18
91
45
30
28
82
9
9 exist.
13
14
15
66
76
0
显示的网页如下：
总结
本文简单介绍了红黑树的概念、算法实现，并进行了实践。
后续我有时间再慢慢补充相关知识点和可能遇到的问题。
