一个简单的红黑树C语言实现

仅供参考，不知道逻辑是否完全正确，只是简单的验证了下:).

代码如下：

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct _rbnode

{

	struct _rbnode *left;

	struct _rbnode *right;

	struct _rbnode *parent;

	int key, color;

} node;



node nilnode = {.left = NULL, .right = NULL, .parent = NULL, .color = 0, .key = 0};

node* nil = &nilnode;



#define COLOR(x) ((x)->color)



void left_rotate(node** T, node* x)

{

	node* y = x->right;

	node* w = x->parent;



	if (w == nil) {

		*T = y;

	} else if (x == w->left) {

		w->left = y;

	} else {

		w->right = y;

	}



	x->right = y->left;

	y->left->parent = x;

	y->parent = w;



	y->left = x;

	x->parent = y;

}



void right_rotate(node** T, node* x)

{

	node* y = x->left;

	node* w = x->parent;



	if (w == nil) {

		*T = y;

	} else if (x == w->left) {

		w->left = y;

	} else {

		w->right = y;

	}



	x->left = y->right;

	y->right->parent = x;

	y->right = x;



	y->parent = x->parent;

	x->parent = y;

}



void rb_insert_fixup(node** T, node* x)

{

	while (COLOR(x->parent)) {

		if (x->parent == x->parent->parent->left) {

			node* y = x->parent->parent->right;

			if (COLOR(y)) {

				x->parent->color = 0;

				y->color = 0;

				x->parent->parent->color = 1;

				x = x->parent->parent;

			} else {

				if (x == x->parent->right) {

					x = x->parent;

					left_rotate(T, x);

				}

				x->parent->color = 0;

				x->parent->parent->color = 1;

				right_rotate(T,x->parent->parent);

			}

		} else {

			node* y = x->parent->parent->left;

			if (COLOR(y)) {

				x->parent->color = 0;

				y->color = 0;

				x->parent->parent->color = 1;

				x = x->parent->parent;

			} else {

				if (x == x->parent->left) {

					x = x->parent;

					right_rotate(T, x);

				}

				x->parent->color = 0;

				x->parent->parent->color = 1;

				left_rotate(T, x->parent->parent);

			}

		}

	}



	(*T)->color = 0;

}



void rb_insert(node** T, node* x)

{

	node* y = nil;

	node* z = *T;



	while (z != nil) {

		y = z;

		if (x->key < z->key) {

			z = z->left;

		} else {

			z = z->right;

		}

	}



	x->parent = y;

	if (y == nil) {

		*T = x;

	} else if (x->key < y->key){

		y->left = x;

	} else {

		y->right = x;

	}



	x->left = nil;

	x->right = nil;

	x->color = 1;

	rb_insert_fixup(T, x);

}



node* tree_minimum(node* z)

{

	while (z->left != nil) {

		z = z->left;

	}



	return z;

}



node* tree_successor(node* z)

{

	if (z->right != nil) {

		return tree_minimum(z->right);

	}



	node* y = z->parent;

	while (y != nil && z == y->right) {

		z = y;

		y = y->parent;

	}

	return y;

}



void rb_delete_fixup(node** T, node* x)

{

	while (x != *T && COLOR(x) == 0) {

		if (x == x->parent->left) {

			node* w = x->parent->right;

			if (COLOR(w)) {

				w->color = 0;

				x->parent->color = 1;

				left_rotate(T, x->parent);

				w = x->parent->right;

			}



			if (COLOR(w->left) == 0 && COLOR(w->right) == 0) {

				w->color = 1;

				x = x->parent;

			} else {

				if (COLOR(w->right) == 0) {

					w->left->color = 0;

					w->color = 1;

					right_rotate(T, w);

					w = x->parent->right;

				}

				w->color = x->parent->color;

				x->parent->color = 0;

				w->right->color = 0;

				left_rotate(T, x->parent);

				x = *T;

			}

		} else {

			node* w = x->parent->left;

			if (COLOR(w)) {

				w->color = 0;

				x->parent->color = 1;

				right_rotate(T, x->parent);

				w = x->parent->left;

			}



			if (COLOR(w->left) == 0 && COLOR(w->right) == 0) {

				w->color = 1;

				x = x->parent;

			} else {

				if (COLOR(w->left) == 0) {

					w->right->color = 0;

					w->color = 1;

					left_rotate(T, w);

					w = x->parent->left;

				}

				w->color = x->parent->color;

				x->parent->color = 0;

				w->left->color = 0;

				right_rotate(T, x->parent);

				x = *T;

			}

		}

	}

	x->color = 0;

}



node* rb_delete(node** T, node* z)

{

	node* y;

	node* x;



	if (z->left == nil || z->right == nil) {

		y = z;

	} else {

		y = tree_successor(z);

	}



	if (y->left != nil) {

		x = y->left;

	} else {

		x = y->right;

	}



	x->parent = y->parent;

	if (y->parent == nil) {

		*T = x;

	} else if (y == y->parent->left) {

		y->parent->left = x;

	} else {

		y->parent->right = x;

	}



	if (y != z) {

		z->key = y->key;

	}



	if (y->color == 0) {

		rb_delete_fixup(T, x);

	}



	return y;

}



void print_tree(node* t)

{

	if (t == nil) return;

	print_tree(t->left);

	printf("%d,%d ", t->key,t->color);

	print_tree(t->right);

}



node *RBT = &nilnode;

int main(void)

{



	int keys[] = {5,4,3,9,7};

	int i;



	node* a;

	node* b;

	for (i=0;i<5;i++) {

		node* temp = (node *)malloc(sizeof(node));

		temp->key = keys[i];

		rb_insert(&RBT,temp);

		if (keys[i] == 4) a = temp;

	}



	printf("R: %d\n", RBT->key);

	print_tree(RBT);

	printf("\n");

	b = rb_delete(&RBT,a);

	free(b);

	printf("R: %d\n", RBT->key);

	print_tree(RBT);

}