红黑树入门

　　　　红黑树 （参看《算法导论》）

　　红黑树是一种平衡二叉树，巧妙地利用结点颜色来简化维护平衡的难度。具有如下性质：

　　1.红黑树上所有结点要么是红色的，要么是黑色的。

　　2.红黑树的根节点是黑色的。

　　3.如果一个结点是红色的，那么他的两个子结点必须是黑色的。

　　4.对于每一个结点，他左子树的黑色结点数量必然等于右子树的黑色结点数量。

　　5.所有叶子结点必然是黑色的。

　　（一）抛弃原有的NULL，所有指向NULL的指针，改为指向一个与普通结点相同的T.null结点，T.null结点颜色固定为黑色，这样便解决了叶子结点的问题，同时根结点的父指针也指向它。

　　（二）每次新插入结点为红色，这样不影响性质1、4、5，也就是说当插入结点时，只可能影响到性质2或者3，维护起来方便，可以向上维护，（插入结点设为x），如果x为根结点，那么可以直接改成黑色，如果不是，那么判断父结点是不是红色，如果是，说明违背了性质3，可以通过旋转、上升矛盾（直至根）来解决。

　　（三）删除一个结点，寻找替代的结点，也就是后继，将这个替代点改成与原要删除的点一样的颜色，这么，问题就缩小到替代点原位置可能少了一个黑结点，那么可以通过上升矛盾子树（即令与他相对应的兄弟子树也少一个黑结点，那么便变成父结点所在的子树少了一个黑结点）或者红转黑来解决，需要注意的是不要在维护过程中，违背更多的红黑树性质。

　　

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define RED 0
#define BLACK 1

typedef struct node
{
  bool color;   //结点颜色，红色或者黑色
  int data;     //数据存放
  struct node *fa,*lchild,*rchild; //三个指针
}RB_Node;

typedef struct
{
  RB_Node *root; //指向树的根节点
  RB_Node *null; //在红黑树中用来代替NULL，方便编程
}Tree;

Tree *Tree_Init()
{
  Tree *T;
  T=(Tree *)malloc(sizeof(Tree));
  T->null=(RB_Node *)malloc(sizeof(RB_Node));
  T->null->color=BLACK;
  T->null->lchild=T->null;
  T->null->rchild=T->null;
  T->null->fa=T->null;
  T->root=T->null;
  return T;
}

RB_Node *Node_Init(Tree *T)
{
  RB_Node *s;
  s=(RB_Node *)malloc(sizeof(RB_Node));
  s->color=RED;
  s->lchild=T->null;
  s->rchild=T->null;
  s->fa=T->null;
  return s;
}

void RB_Left_Rotate(Tree *T,RB_Node *x) //左旋转，原本为  （x在上），旋转为 /（x在下）
{
  RB_Node *y=x->rchild;
  x->rchild=y->lchild;
  y->lchild->fa=x;
  if(x==T->root) T->root=y;
  else
  {
    if(x==x->fa->lchild) x->fa->lchild=y;
    else x->fa->rchild=y;
  }
  y->fa=x->fa;
  y->lchild=x;
  x->fa=y;
}

void RB_Right_Rotate(Tree *T,RB_Node *x) //右旋转，原本为 / （x在上），旋转为 （x在下）
{
  RB_Node *y=x->lchild;
  x->lchild=y->rchild;
  y->rchild->fa=x;
  if(x==T->root) T->root=y;
  else
  {
    if(x==x->fa->lchild) x->fa->lchild=y;
    else x->fa->rchild=y;
  }
  y->fa=x->fa;
  y->rchild=x;
  x->fa=y;
}

void RB_Adjust_Insert(Tree *T,RB_Node *x)
{
  while(x->fa->color==RED)
  {
    if(x->fa==x->fa->fa->lchild)
    {
      RB_Node *y=x->fa->fa->rchild;
      if(y->color==RED)
      {
        y->color=BLACK;
        x->fa->color=BLACK;
        x->fa->fa->color=RED;
        x=x->fa->fa;
      }
      else if(x==x->fa->rchild)
      {
        x=x->fa;
        RB_Left_Rotate(T,x);
      }
      else
      {
        x->fa->fa->color=RED;
        x->fa->color=BLACK;
        RB_Right_Rotate(T,x->fa->fa);
      }
    }
    else
    {
      RB_Node *y=x->fa->fa->lchild;
      if(y->color==RED)
      {
        y->color=BLACK;
        x->fa->color=BLACK;
        x->fa->fa->color=RED;
        x=x->fa->fa;
      }
      else if(x==x->fa->lchild)
      {
        x=x->fa;
        RB_Right_Rotate(T,x);
      }
      else
      {
        x->fa->fa->color=RED;
        x->fa->color=BLACK;
        RB_Left_Rotate(T,x->fa->fa);
      }
    }
  }
  T->root->color=BLACK;
}

void RB_Insert(Tree *T,RB_Node *x)
{
  //新插入结点显红色，可以在函数外面写
  RB_Node *p=T->root,*q;
  if(p==T->null)
  {
    T->root=x;
    x->color=BLACK;
    return ;
  }
  while(p!=T->null)
  {
    q=p;
    if(x->data>=p->data) p=p->rchild;
    else p=p->lchild;
  }
  if(x->data>=q->data) q->rchild=x;
  else q->lchild=x;
  x->fa=q;
  RB_Adjust_Insert(T,x);
}

RB_Node *RB_Search_MinMum(Tree *T,RB_Node *x)
{
  while(x->lchild!=T->null)
  {
    x=x->lchild;
  }
  return x;
}

void RB_Transplant(Tree *T,RB_Node *u,RB_Node *v)
{
  if(u->fa==T->null) T->root=v;
  else if(u->fa->lchild==u) u->fa->lchild=v;
  else u->fa->rchild=v;
  v->fa=u->fa;
}

void RB_Adjust_Delete(Tree *T,RB_Node *x)
{
  while(x!=T->root&&x->color==BLACK)
  {
    if(x==x->fa->lchild)
    {
      RB_Node *w=x->fa->rchild;
      if(w->color==RED)
      {
        w->color=BLACK;
        x->fa->color=RED;
        RB_Left_Rotate(T,x->fa);
        w=x->fa->rchild;
      }
      else if(w->lchild->color==BLACK&&w->rchild->color==BLACK)
      {
        w->color==RED;
        x=x->fa;
      }
      else if(w->rchild->color==BLACK)
      {
        w->lchild->color=BLACK;
        w->color=RED;
        RB_Right_Rotate(T,w);
        w=x->fa->rchild;
      }
      else
      {
        w->color=x->fa->color;
        x->fa->color=BLACK;
        w->rchild->color=BLACK;
        RB_Left_Rotate(T,x->fa);
        x=T->root;
      }
    }
    else
    {
      RB_Node *w=x->fa->lchild;
      if(w->color==RED)
      {
        w->color=BLACK;
        x->fa->color=RED;
        RB_Right_Rotate(T,x->fa);
        w=x->fa->lchild;
      }
      else if(w->lchild->color==BLACK&&w->rchild->color==BLACK)
      {
        w->color=RED;
        x=x->fa;
      }
      else if(w->lchild->color==BLACK)
      {
        w->rchild->color=BLACK;
        w->color=RED;
        RB_Left_Rotate(T,w);
        w=x->fa->lchild;
      }
      else
      {
        w->color=x->fa->color;
        x->fa->color=BLACK;
        w->lchild->color=BLACK;
        RB_Right_Rotate(T,x->fa);
        x=T->root;
      }
    }
  }
  x->color=BLACK;
}

void RB_Delete(Tree *T,RB_Node *z)
{
  RB_Node *y=z,*x;
  bool y_original_color=y->color;
  if(z->lchild==T->null)
  {
    x=z->rchild;
    RB_Transplant(T,z,z->rchild);
    free(z);
  }
  else if(z->rchild==T->null)
  {
    x=z->lchild;
    RB_Transplant(T,z,z->lchild);
    free(z);
  }
  else
  {
    y=RB_Search_MinMum(T,z->rchild);
    y_original_color=y->color;
    x=y->rchild;
    if(y->fa==z)
      x->fa=y;  //等会要从x处开始调整，如果x为T->null，那么现在先预置T->null的父结点为y
    else
    {
      RB_Transplant(T,y,y->rchild);
      y->rchild=z->rchild;
      y->rchild->fa=y; //也有上面x->fa=y;的效果
    }
    RB_Transplant(T,z,y);
    y->lchild=z->lchild;
    y->lchild->fa=y;
    y->color=z->color;
    free(z);
  }
  if(y_original_color==BLACK)
    RB_Adjust_Delete(T,x);
}

void RB_Display_Tree(Tree *T,RB_Node *p,int floor=0)
{
  if(p==T->null) return;
  RB_Display_Tree(T,p->lchild,floor+1);
  for(int i=0;i<floor;i++)
    printf(" ");
  printf("%d %s
",p->data,p->color==BLACK?"BLACK":"RED");
  RB_Display_Tree(T,p->rchild,floor+1);
}

RB_Node *RB_Search(Tree *T,int data)      //找到第一个，如果没有，返回T->null
{
  RB_Node *p=T->root;
  while(p!=T->null)
  {
    if(p->data==data) return p;
    if(data>p->data) p=p->rchild;
    else p=p->lchild;
  }
  return T->null;
}

void RB_Clear(Tree *T,RB_Node *x)
{
  if(x!=T->null)
  {
    RB_Clear(T,x->lchild);
    RB_Clear(T,x->rchild);
    free(x);
  }
}

void CE_SHI()   //用于测试红黑树
{
  Tree *T;
  T=Tree_Init();
  while(1)
  {
    printf("
--------红黑树---------------
");
    printf("1. 添加结点
");
    printf("2. 删除结点
");
    printf("0. 退出
");
    int ch;
    scanf("%d",&ch);
    if(ch==1)
    {
      printf("请输入关键字：");
      scanf("%d",&ch);
      RB_Node *x;
      x=Node_Init(T);
      x->data=ch;
      RB_Insert(T,x);
      RB_Display_Tree(T,T->root);
    }
    else if(ch==2)
    {
      printf("请输入关键字：");
      scanf("%d",&ch);
      RB_Node *x=RB_Search(T,ch);
      RB_Delete(T,x);
      RB_Display_Tree(T,T->root);
    }
    else if(ch==0)
    {
      RB_Clear(T,T->root);
      T->root=T->null;
    }
    system("pause");
    system("cls");
    RB_Display_Tree(T,T->root);
  }
  free(T);
}

int main()
{
  CE_SHI();
  return 0;
}