算法导论红黑树实现

算法导论红黑树实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define RED 1
#define BLACK 0
#define BOOL int
#define TRUE 1
#define FALSE 0

typedef struct rbtree
{
    struct rbtree *p;
    struct rbtree *left;
    struct rbtree *right;
    int key;
    int color;
}RBTREE;

RBTREE *m_ptNilNode=NULL;//哨兵节点
RBTREE *m_ptRoot=NULL;
void InOrderTraverse(RBTREE* ptNode)
{
    if (ptNode == m_ptNilNode)
    {
        return;
    }
    else
    {
        InOrderTraverse(ptNode->left);
        printf("%d ",ptNode->key);
        InOrderTraverse(ptNode->right);
    }
}

RBTREE *find(int key)
{
    RBTREE *ptNode=m_ptRoot;
    while(ptNode!=m_ptNilNode)
    {
        if(key<ptNode->key)
        {
            ptNode=ptNode->left;
        }
        else if(key>ptNode->key)
        {
            ptNode=ptNode->right;
        }
        else
            break;
    }
    return ptNode;
}
BOOL leftrotate(RBTREE *ptxNode)
{
    if(m_ptNilNode == ptxNode  || m_ptNilNode == ptxNode->right )
        return FALSE;
    RBTREE *ptyNode=ptxNode->right;
    ptxNode->right=ptyNode->left;
    if(ptyNode->left != m_ptNilNode)
    {
        ptyNode->left->p=ptxNode;
    }

    ptyNode->p=ptxNode->p;
    if(m_ptNilNode==ptxNode->p)
    {
        m_ptRoot=ptyNode;
        m_ptNilNode->left = m_ptRoot;
        m_ptNilNode->right=m_ptRoot;
    }
    else
    {
        if(ptxNode==ptxNode->p->left)
        {
            ptxNode->p->left=ptyNode;
        }
        else
        {
            ptxNode->p->right=ptyNode;
        }
    }

    ptyNode->left=ptxNode;
    ptxNode->p=ptyNode;
    return TRUE;
}

BOOL rightrotate(RBTREE *ptyNode)
{
    if(m_ptNilNode==ptyNode || m_ptNilNode == ptyNode->left )
        return FALSE;
    RBTREE *ptxNode=ptyNode->left;
    ptyNode->left=ptxNode->right;
    if(ptxNode->right!=m_ptNilNode)
        ptxNode->right->p=ptyNode;
    ptxNode->p=ptyNode->p;
    if(m_ptNilNode==ptyNode->p)
    {
        m_ptRoot=ptxNode;
        m_ptNilNode->left = m_ptRoot;
        m_ptNilNode->right=m_ptRoot;
    }
    else
    {
        if(ptyNode==ptyNode->p->right)
        {
            ptyNode->p->right=ptxNode;
        }
        else
        {
            ptyNode->p->left=ptxNode;
        }
    }

    ptxNode->right=ptyNode;
    ptyNode->p=ptxNode;
    return TRUE;
}

void rbinsertfixup(RBTREE *ptNode)
{
    RBTREE  *ptyNode=m_ptNilNode;//叔叔节点
    while(RED == ptNode->p->color)
    {
        if(ptNode->p==ptNode->p->p->left)
        {
            ptyNode=ptNode->p->p->right;
            if(RED == ptyNode->color)//case 1 z的叔叔y是红色的
            {
                ptNode->p->color=BLACK;
                ptyNode->color=BLACK;
                ptNode->p->p->color=RED;
                ptNode=ptNode->p->p;
            }
            else if(BLACK == ptyNode->color)
            {
                if(ptNode==ptNode->p->right)//case 2 z的叔叔是y是红的，且z是右节点
                {
                    ptNode=ptNode->p;
                    leftrotate(ptNode);
                }
                ptNode->p->color=BLACK;
                ptNode->p->p->color=RED;
                rightrotate(ptNode->p->p);
            }

        }
        else
        {
            ptyNode=ptNode->p->p->left;
            if(RED == ptyNode->color)//case 1 z的叔叔y是红色的
            {
                ptNode->p->color=BLACK;
                ptyNode->color=BLACK;
                ptyNode->p->color=RED;
                ptNode=ptNode->p->p;
            }
            else if(BLACK== ptyNode->color)
            {
                if(ptNode==ptNode->p->left)//case 2 z的叔叔是y是红的，且z是右节点
                {
                    ptNode=ptNode->p;
                    rightrotate(ptNode);
                }
                ptNode->p->color=BLACK;
                ptNode->p->p->color=RED;
                leftrotate(ptNode->p->p);
            }

        }
    }
}


void rbInsert(RBTREE *ptNode)
{
    RBTREE *ptyNode=m_ptNilNode;
    RBTREE *ptxNode=m_ptRoot;
    while(ptxNode!=m_ptNilNode)
    {
        ptyNode=ptxNode;
        if(ptNode->key<ptxNode->key)
        {
            ptxNode=ptxNode->left;
        }
        else
        {
            ptxNode=ptxNode->right;
        }
    }
    ptNode->left=m_ptNilNode;
    ptNode->right=m_ptNilNode;
    ptNode->color=RED;
    if(ptyNode==m_ptNilNode)
    {
        m_ptRoot=ptNode;
        m_ptRoot->p=m_ptNilNode;
        m_ptNilNode->left = m_ptRoot;
        m_ptNilNode->right=m_ptRoot;
        m_ptNilNode->p=m_ptRoot;
    }
    else if(ptNode->key > ptyNode->key)
    {
        ptyNode->right=ptNode;
    }
    else
    {
        ptyNode->left=ptNode;
    }
    ptNode->p=ptyNode;

    rbinsertfixup(ptNode);
    //InOrderTraverse(m_ptRoot);
}

void rbtransplant(RBTREE *ptuNode,RBTREE*ptvNode)
{
    if(m_ptNilNode==ptuNode->p)
    {
        m_ptRoot=ptvNode;
    }
    else if(ptuNode==ptuNode->p->left)
    {
        ptuNode->p->left=ptvNode;
    }
    else
        ptuNode->p->right=ptvNode;
    ptvNode->p=ptuNode->p;
}

RBTREE *treemininum(RBTREE *ptNode)
{
    while(ptNode->left!=m_ptNilNode)
    {
        ptNode=ptNode->left;
    }
    return ptNode;
}

void rbdeletefixup(RBTREE *ptxNode)
{
    RBTREE *ptwNode=m_ptNilNode;
    while(ptxNode!=m_ptRoot && ptxNode->color==BLACK)
    {
        if(ptxNode==ptxNode->p->left)
        {
            ptwNode=ptxNode->p->right;
            if(RED==ptwNode->color)
            {
                ptwNode->color=BLACK;
                ptxNode->p->color=RED;
                leftrotate(ptxNode->p);
                ptwNode=ptxNode->p->right;
            }
            if(ptwNode->left->color==BLACK && ptwNode->right->color==BLACK )
            {
                ptwNode->color=RED;
                ptxNode=ptxNode->p;
            }
            else if(ptwNode->right->color==BLACK)
            {
                ptwNode->left->color=BLACK;
                ptwNode->color=RED;
                rightrotate(ptwNode);
                ptwNode=ptxNode->p->right;
            }
            ptwNode->color=ptxNode->p->color;
            ptxNode->p->color=BLACK;
            ptwNode->right->color=BLACK;
            leftrotate(ptxNode->p);
            ptxNode=m_ptRoot;
        }
        else
        {
            ptwNode=ptxNode->p->left;
            if(RED==ptwNode->color)
            {
                ptwNode->color=BLACK;
                ptxNode->p->color=RED;
                rightrotate(ptxNode->p);
                ptwNode=ptxNode->p->right;
            }
            if(ptwNode->left->color==BLACK && ptwNode->right->color==BLACK )
            {
                ptwNode->color=RED;
                ptxNode=ptxNode->p;
            }
            else if(ptwNode->left->color==BLACK)
            {
                ptwNode->right->color=BLACK;
                ptwNode->color=RED;
                leftrotate(ptwNode);
                ptwNode=ptxNode->p->left;
            }
            ptwNode->color=ptxNode->p->color;
            ptxNode->p->color=BLACK;
            ptwNode->left->color=BLACK;
            leftrotate(ptxNode->p);
            ptxNode=m_ptRoot;
        }
    }
    ptxNode->color=BLACK;
}
void rbdelete(RBTREE *ptzNode)
{
    RBTREE *ptyNode=ptzNode;
    RBTREE *ptxNode=m_ptNilNode;
    if(ptzNode==m_ptNilNode)
        return ;
    int yoriginalcolor=ptyNode->color;
    if(ptzNode->left==m_ptNilNode)
    {
        ptxNode=ptzNode->right;
        rbtransplant(ptzNode,ptzNode->right);
    }
    else if(ptzNode->right==m_ptNilNode)
    {
        ptxNode=ptzNode->left;
        rbtransplant(ptzNode,ptzNode->left);
    }
    else
    {
        ptyNode=treemininum(ptzNode->right);
        yoriginalcolor=ptyNode->color;
        ptxNode=ptyNode->right;
        if(ptyNode->p==ptzNode)
        {
            ptxNode->p=ptyNode;
        }
        else
        {
            rbtransplant(ptyNode,ptyNode->right);
            ptyNode->right=ptzNode->right;
            ptyNode->right->p=ptyNode;
        }
        rbtransplant(ptzNode,ptyNode);
        ptyNode->left=ptzNode->left;
        ptyNode->left->p=ptyNode;
        ptyNode->color=ptzNode->color;
    }
    if(yoriginalcolor==BLACK)
        rbdeletefixup(ptxNode);
    free(ptzNode);
}


int main()
{
    m_ptNilNode =(RBTREE *)malloc(sizeof(RBTREE));
    memset(m_ptNilNode,0,sizeof(RBTREE));//哨兵节点颜色为黑
    m_ptRoot= m_ptNilNode;

    int a[]={4,19,0,17,10,12,8,11,18,1,6,16,7,14,9,3,13,2,5,15,4};
    int i=0;
    for(i=0;i<sizeof(a)/sizeof(int);++i)
    {
        RBTREE *ptNode=(RBTREE *)malloc(sizeof(RBTREE));
        ptNode->key=a[i];
        rbInsert(ptNode);
    }
    InOrderTraverse(m_ptRoot);
    printf("\n");

    for(i=0;i<sizeof(a)/sizeof(int);++i)
    {
        RBTREE *ptIndex=find(a[i]);
        printf("delete %d\n",a[i]);
        rbdelete(ptIndex);  //删除结点
        InOrderTraverse(m_ptRoot);
        printf("\n");

    }

    return 0;
}