建立红黑树的完整可行代码（算法导论）

推荐一篇介绍红黑树的良心博客

首先要说明我学习红黑树插入时的经验：初次看时很懵逼，不要紧，放到第二天再看一遍就清楚多了，这时候开始自己把算法整理一遍。第三天再看了然于心，可以再把各种情况考虑一遍，然后就可以写代码了。必须说明的是，《算法导论》上的伪代码真的丑，显得没有什么条理，而且漏掉了几个细节，所有直接按书写的代码不经过细心调试是不能成功的。所有我推荐不看书自己写出来，肯定比看书快而且准确。

算法过程我就不介绍了，我写也不可能比上面那篇博客好。总之首先搞清楚旋转，再根据旋转过程来考虑各种情况是不会错的。我只奉上代码

1. 输入：总数小于500的一组数字，数字之间以空格隔开，换行再CTRL+Z结束输入
2. 输出：对建立的红黑树的中序遍历，应为顺序

代码

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<queue>
using namespace std;
#define NIL 500
#define RED 0
#define BLACK 1
int Troot=1;

void RIGHT_ROTATE(int*L,int*R,int*P,int y)//y!=NIL && L[y]!=NIL
{
    int x=L[y];int A=P[y],D=R[x];
    if(D!=NIL) P[D]=y;
    P[x]=A;
    P[y]=x;
    R[x]=y;
    L[y]=D;
    if(A!=NIL)
    {
        if(L[A]==y) L[A]=x;
        else R[A]=x;
    }
    else Troot=x;
}
void LEFT_ROTATE(int*L,int*R,int*P,int x)//x!=NIL && R[x]!=NIL
{
    int y=R[x];int A=P[x],D=L[y];
    if(D!=NIL) P[D]=x;
    P[y]=A;
    P[x]=y;
    L[y]=x;
    R[x]=D;
    if(A!=NIL)
    {
        if(L[A]==x) L[A]=y;
        else R[A]=y;
    }
    else Troot=y;
}

void RB_INSERT_FIXUP(int*KEY,int*L,int*R,int*P,bool*C,int z)
{
    while(z!=Troot && C[P[z]]==RED)
    {
        if(P[z]==L[P[P[z]]]) //父左则叔右
        {
            int y=R[P[P[z]]];//定义y为叔节点
            if(C[y]==BLACK)//如果父左叔黑
            {
                if(z==L[P[z]])//如果父左叔黑插左
                {
                    int x=P[z];
                    y=P[P[z]];//定义父亲节点为x，祖父节点为y
                    RIGHT_ROTATE(L,R,P,y);//右旋
                    C[x]=BLACK;C[y]=RED;//染色
                }
                else //如果父左叔黑插右
                {
                    int x=P[z];
                    y=P[P[z]];//定义父节点为x祖父节点为y
                    LEFT_ROTATE(L,R,P,x);//左旋父节点
                    z=x;//更新插入节点
                }
            }
            else //如果父左叔红
            {
                int x=P[z];y=P[P[z]];
                int B=R[y];//重新设定x,y和B
                C[x]=BLACK;C[B]=BLACK;C[y]=RED;
                z=y;
            }
        }
        else //父右则叔左
        {
            int y=L[P[P[z]]];
            if(C[y]==BLACK)//父右叔黑
            {
                if(z==R[P[z]])//如果父右叔黑插右
                    {
                        int x=P[P[z]];
                        y=P[z];  //按图定义x和y
                        LEFT_ROTATE(L,R,P,x);
                        C[y]=BLACK;C[x]=RED;
                    }
                    else //父右叔黑插左
                    {
                        int x=P[P[z]];
                        y=P[z];
                        RIGHT_ROTATE(L,R,P,y);
                        z=y;
                    }
            }
            else //父右叔红
            {
                int x=P[P[z]];y=P[z];//按图定义x,y
                int D=L[x];
                C[D]=BLACK;C[y]=BLACK;C[x]=RED;
                z=x;
            }
        }
     C[Troot]=BLACK;
    }
}

void RB_INSERT(int*KEY,int*L,int*R,int*P,bool*C,int N)
{
    for(int k=2;k<=N;k++)
    {
        int y=NIL,x=Troot;
        while(x!=NIL)
        {
            y=x;
            if(KEY[k]<KEY[x]) x=L[x];
            else x=R[x];
        }
        P[k]=y;
        if(KEY[k]<KEY[y]) L[y]=k;
        else R[y]=k;
        C[k]=RED;
        RB_INSERT_FIXUP(KEY,L,R,P,C,k);
    }
}

void OUT_PUT(int*KEY,int*LEFT,int*RIGHT,int k)
{
    if(LEFT[k]!=NIL) OUT_PUT(KEY,LEFT,RIGHT,LEFT[k]);
    printf("%d  ",KEY[k]);
    if(RIGHT[k]!=NIL) OUT_PUT(KEY,LEFT,RIGHT,RIGHT[k]);
}

int main()
{
int key,N=0;
queue<int>import;
 while(scanf("%d",&key)!=EOF)
 {
     N++;
     import.push(key);
 }
int *KEY=(int*)malloc(sizeof(int)*(N+2));fill(KEY,KEY+(N+2),NIL);
for(int i=1;i<=N;i++)
{
    KEY[i]=import.front();
    import.pop();
}

int *LEFT=(int*)malloc(sizeof(int)*(N+2));fill(LEFT,LEFT+(N+2),NIL);
int *RIGHT=(int*)malloc(sizeof(int)*(N+2));fill(RIGHT,RIGHT+(N+2),NIL);
int *PARENT=(int*)malloc(sizeof(int)*(N+2));fill(PARENT,PARENT+(N+2),NIL);
bool*COLOR=(bool*)malloc(sizeof(bool)*(NIL+10));fill(COLOR,COLOR+(NIL+10),BLACK);
RB_INSERT(KEY,LEFT,RIGHT,PARENT,COLOR,N);
OUT_PUT(KEY,LEFT,RIGHT,Troot);
return 0;
}