红黑树_pta红黑树-CSDN博客

本文链接：https://blog.csdn.net/D_mengxin/article/details/86620741

红黑树

红黑树是一颗二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的。
树中每个结点包含5个属性：color、key、left、right、p。如果一个结点没有子结点或父结点，则该结点相应指针属性的值为NIL，我们可以把这些NIL视为指向二叉搜索树的叶结点（外部结点）的指针，而把带关键字的结点视为树的内部结点。
一颗红黑树是满足下面红黑性质的二叉搜索树：
1、每个结点或是红色的，或是黑色的。
2、根节点是黑色的。
3、每个叶结点（NIL）是黑色的。
4、如果一个结点是红色的，则它的两个子结点都是黑色的。
5、对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。

使用一个哨兵T.nil来代表所有的NIL，哨兵的属性p、left、right、key的取值并不重要

#include<stdio.h>
#include<stdlib.h>
#define RED 0
#define BLACK 1
struct node {
	int key;
	int color;
	int size;    //树的规模
	struct node *left;  //左孩子
	struct node *right;  //右孩子
	struct node *p;    //父结点
};
struct Tree {
	struct node *root;
	struct node *nil;
};

左旋

void LEFT_ROTATE(struct Tree &T, struct node *x) {
	struct node *y = x->right;
	x->right = y->left;
	if(y->left != T.nil)
		y->left->p = x;
	y->p = x->p;
	if(x->p == T.nil)
		T.root = y;
	else if(x == x->p->left)
		x->p->left = y;
	else
		x->p->right = y;
	y->left = x;
	x->p = y;
	//后两行是用于维护树的规模
	y->size = x->size;
	x->size = x->left->size + x->right->size + 1;
}

右旋

void RIGHT_ROTATE(struct Tree &T, struct node *x) {
	struct node *y = x->left;
	x->left = y->right;
	if(y->right != T.nil)
		y->right->p = x;
	y->p = x->p;
	if(x->p == T.nil)
		T.root = y;
	else if(x == x->p->left)
		x->p->left = y;
	else
		x->p->right = y;
	y->right = x;
	x->p = y;
	//后两行是用于维护树的规模
	y->size = x->size;
	x->size = x->left->size + x->right->size + 1;
}

插入

void RB_INSERT_FIXUP(struct Tree &T, struct node *z) {
	while(z->p->color == RED) {
		if(z->p == z->p->p->left) {
			struct node *y = z->p->p->right;
			if(y!=NULL&&y->color == RED) {   //case 1
				z->p->color = BLACK;         //case 1
				y->color = BLACK;            //case 1
				z->p->p->color = RED;        //case 1
				z = z->p->p;                 //case 1
				continue;                    //case 1
			} else {
				if(z == z->p->right) {       //case 2
					z = z->p;                //case 2
					LEFT_ROTATE(T,z);        //case 2
				}
				z->p->color = BLACK;         //case 3
				z->p->p->color = RED;        //case 3
				RIGHT_ROTATE(T,z->p->p);     //case 3
			}
		} else {
			struct node *y = z->p->p->left;
			if(y!=NULL&&y->color == RED) {
				z->p->color = BLACK;
				y->color = BLACK;
				z->p->p->color = RED;
				z = z->p->p;
				continue;
			} else {
				if(z == z->p->left) {
					z = z->p;
					RIGHT_ROTATE(T,z);
				}
				z->p->color = BLACK;
				z->p->p->color = RED;
				LEFT_ROTATE(T,z->p->p);

			}
		}
	}
	T.root->color = BLACK;
}
void RB_INSERT(struct Tree &T, struct node *z) {
	struct node *y = T.nil;
	struct node *x = T.root;
	while(x != T.nil) {
		x->size++;  //维护树的规模
		y = x;
		if(z->key < x->key)
			x = x->left;
		else
			x = x->right;
	}
	z->p = y;
	if(y == T.nil)
		T.root = z;
	else if(z->key < y->key)
		y->left = z;
	else
		y->right = z;
	z->left = T.nil;
	z->right = T.nil;
	z->color = RED;
	z->size = 1;   //维护树的规模
	RB_INSERT_FIXUP(T,z);
}

删除


struct node *TREE_MINIMUM(struct node *r,struct node *nil){
	while(r->left != nil){
		r = r->left;
	}
	return r;
}
void RB_DELETE_FIXUP(struct Tree &T, struct node *x){
	while(x != T.root && x->color == BLACK){
		struct node *w;
		if(x == x->p->left){
			w = x->p->right;
			if(w->color == RED){       //case 1
				w->color = BLACK;      //case 1
				x->p->color = RED;     //case 1
				LEFT_ROTATE(T,x->p);   //case 1
				w = x->p->right;       //case 1
			}
			if(w->left->color == BLACK && w->right->color == BLACK){  //case 2
				w->color = RED;      //case 2
				x = x->p;            //case 2
			}
			else {
				if(w->right->color == BLACK){   //case 3
					w->left->color = BLACK;     //case 3
					w->color = RED;             //case 3
					RIGHT_ROTATE(T,w);          //case 3
					w = x->p->right;            //case 3
				}
				w->color = x->p->color;         //case 4
				x->p->color = BLACK;            //case 4
				w->right->color = BLACK;        //case 4
				LEFT_ROTATE(T,x->p);            //case 4
				x = T.root;
			}
		}else{
			w = x->p->left;
			if(w->color == RED){
				w->color = BLACK;
				x->p->color = RED;
				RIGHT_ROTATE(T,x->p);
				w = x->p->right;
			}
			if(w->left->color == BLACK && w->right->color == BLACK){
				w->color = RED;
				x = x->p;
			}
			else{
				if(w->left->color == BLACK){
					w->right->color = BLACK;
					w->color = RED;
					LEFT_ROTATE(T,w);
					w = x->p->right;
				}
				w->color = x->p->color;
				x->p->color = BLACK;
				w->left->color = BLACK;
				RIGHT_ROTATE(T,x->p);
				x = T.root;
			}
		}
	}
}
void RB_TRANSPLANT(struct Tree &T, struct node *u, struct node *v){
	//这里是把要u的父结点改为v的父结点 
	if(u->p == T.nil)
		T.root = v;
	else if(u == u->p->left)
		u->p->left = v;
	else
		u->p->right = v;
	v->p = u->p;
}
void DELETE_MAINTAIN(struct Tree &T, struct node *x){ //重新计算从结点x到根的各节点的规模
	struct node *y = x->p;
	while(y != T.nil){
		y->size = y->left->size + y->right->size + 1;
		y = y->p; 
	}
	y->size = 0;
}
void RB_DELETE(struct Tree &T, struct node *z){
	struct node *y = z;
	struct node *x;
	int y_original_color = y->color;
	if(z->left == T.nil){//如果z没有左孩子 
		x = z->right;
		RB_TRANSPLANT(T,z,z->right);
	}else if(z->right == T.nil){//如果z没有右孩子 
		x = z->left;
		RB_TRANSPLANT(T,z,z->left);
	}else{
		y = TREE_MINIMUM(z->right,T.nil);
		y_original_color = y->color;
		x = y->right;//y只可能有右孩子 
		if(x!=T.nil&&y->p == z)//如果后继y是z的子结点
			x->p = y;
		else{
			RB_TRANSPLANT(T,y,y->right);
			y->right = z->right;
			y->right->p = y;
		}
		RB_TRANSPLANT(T,z,y);
		y->left = z->left;
		y->left->p = y;
		y->color = z->color; 
	}
	DELETE_MAINTAIN(T,x);  //维护树的规模
	if(y_original_color == BLACK)
		RB_DELETE_FIXUP(T,x);
}