RBtree详解之删除(含完整红黑树代码)

最新推荐文章于 2023-03-12 17:39:16 发布
最新推荐文章于 2023-03-12 17:39:16 发布
阅读量1.6w 收藏 10
点赞数 3
分类专栏： # 数据结构-查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31821675/article/details/69808265
版权

前面我们讨论了红黑树的插入的实现，基本思想是分类讨论；然后分情况讨论以后我们发现插入操作调整函数只需要处理三种情况，并不是太复杂。但是

删除操作会更复杂一点，因为二叉搜索树的删除操作本身就分成了多种情况，这样在执行删除操作后要处理的情况会更多；下面对于删除操作我们仍旧采

取分类讨论的方法，将所有的情况梳理清楚后，就可以理解红黑树的删除调整函数的实质了。 

下面先放出红黑树删除函数的代码：

//红黑树删除函数
///类似于二叉树删除函数,不过在删除完成以后需要调用调整函数恢复性质
///总的过程也是按z的左右儿子情况进行分类.
///1.z只有左儿子/右儿子
///2.z有左右儿子,z的后继结点是z的右儿子
///3.z有左右儿子,z的后继结点不是z的右儿子
void RBDelete(RBTree &z)
{ ///在下面的过程中y总是指向树中会被删除的结点或是会被替代的结点
    ///x总是指向要替代z或y的结点

    RBTree x=NULL;
    RBTree y=z;
    int ycolor=y->color; ///记录y原来的颜色
    if(z->left==NULL) ///只有右儿子
    {
        x=z->right;
        RBTransplant(z, z->right);// z->right 替换 z
    }
    else if(z->right==NULL) ///只有左儿子
    {
        x=z->left;
        RBTransplant(z, z->left);
    }
    else  ///左右儿子都有
    {
        y=RBTreeMinMuM(z->right); ///查找z的后继
        ycolor=y->color;
        x=y->right; ///因为后面y会被染成z原来的颜色,所以违反性质的就是y的右儿子
        if(y->p==z) ///y是z的孩子结点
        {
            x->p=y;///这种情况下,y为x的父结点

            RBTransplant(z,y); ///y取代z
            y->left=z->left; ///z的左孩子改变指向
            y->left->p=y;
            y->color=z->color; ///更改y的颜色,这样的话从y以上红黑树的性质都不会违反
        }
        else ///y不是z的孩子结点的情况
        {
            RBTransplant(z, y); ///y取代z
            y->left=z->left; ///z的左孩子改变指向
            y->left->p=y;
            y->color=z->color; ///更改y的颜色,这样的话从y以上红黑树的性质都不会违反
            y->right=z->right;
            y->right->p=y;
            RBTransplant(y, y->right);
        }
    }
    delete z;//
    ///如果y原来的颜色是黑色,那么就意味着有一个黑色结点被覆盖了,
    ///红黑树的性质可能会被破坏(性质4或5),需要调整
    if(ycolor==BLACK)
    {
        RBDeleteFixUp(x);
    }
}

我们设要删除的结点为z，在下面的过程中y总是指向树中会被删除的结点或是会被替代的结点而x总是指向要替代z或y的结点；从代码上看，红黑树的删除操作与二叉树搜索树一样都是分三种情况进行的：

1).z只有左儿子/右儿子 
2).z有左右儿子,z的后继结点是z的右儿子 
3).z有左右儿子,z的后继的结点不是z的右儿子 
那么现在我们就来分析这三种情况下删除z需要怎样操作，以及删除z后红黑树的那些性质会被违反，我们如何进行调整以恢复性质。

情况1：z只有左儿子/右儿子 
这种情况下删除操作是很简单的，我们只需要用z的左孩子或右孩子替代z就行了；然后y表示z，x表示z的左孩子或右孩子，ycolor表示z的颜色。 
(1).如果z的颜色为红；那么这种替代以后红黑树不会有任何性质被违反，所以就不需要进行调整。 
(2).如果z的颜色为黑；那么就意味着有一个黑色结点被覆盖了，这时如果替代z的x是黑色，那么就意味着黑高减少，性质5被破坏了，这时我们可以在x上再人为的”增添”一重黑色,此时x变成双重黑色的结点，但是性质5恢复了；如果x是红色，那么如果z的父结点是红色的，那么性质4和性质5都就会被破坏，这时我们就可以将x染成红色，这样性质4，性质5都可以恢复了。

情况2：z有左右儿子，并且其右儿子就是其后继结点 
我们知道一个结点的后继就是将所有结点按关键字从小到大的排序后，排在其后面的那一个结点。z的右儿子就是z的后继，说明z的右儿子的左子树为空。此时y表示z的右儿子，而x表示y的右儿子。删除过程应该是用 y 替代 z, 然后 x 替代 y，并且将y染成z原来的颜色，ycolor表示y原来的颜色。现在因为y替代z以后被染成z原来的颜色，所以至z以上红黑树的所有性质都不会变，唯一有可能会影响红黑树性质的地方在x替代y这一点。所以其实情况有返回到情况1了，下面按y的颜色进行分类讨论： 
(1).y的颜色为红；那么无论x的颜色为红还是为黑，x替换y以后都不会影响任何性质。 
(2).y的颜色为黑；这时与上面的情况1是相似的，如果x为黑，则性质5会被违反，我们通过将其染成双重黑色解决。如果x为红，则性质4,5都会被违反，但是我们可以通过将x染成黑色恢复。

情况3：z有左右儿子，并且z的后继不是其右儿子 
其实这种情况和情况2是基本一样的，唯一不同的点在于y的位置会变。在情况2中y是z的右儿子，而在这里我们需要用一个查找后继的函数查找到y，然后x仍然表示y的右儿子，ycolor表示y的颜色。同样的x取代y，然后y取代z并被染成z原来的颜色。所以我们还是只需要关注x取代y的过程。接下来按y的颜色讨论，其实与上面情况2是一模一样的： 
(1).如果y的颜色为红色；那么无论x为红还是为黑，替换都不会影响任何性质，无需调整。 
(2).y的颜色为黑；如果x为黑，则性质5会被违反，我们通过将其染成双重黑色解决。如果x为红，则性质4,5都会被违反，但是我们可以通过将x染成黑色恢复。

上面的所有情况讨论完了以后，我们就发现如果ycolor为红，则删除以后不需要任何的调整。否则如果ycolor为黑，红黑树的性质就会被违反，需要进入调整函数中调整恢复性质。并且进入调整函数时，如果x为红，那么我们简单的将其染成黑色就可以恢复性质了；如果x为黑，那么进入调整函数是我们就将其看成带有双重黑色的情况，调整函数中需要消除那重额外的黑色。对于x为双重黑色的情况，还有一点需要注意：如果此时x为根结点，我们可以简单的去掉一重黑色就行了(其实就是不需要做任何操作)，这时黑高是不会受影响的。所以我们下面集中精力来讨论如何调整双重黑色的情况。

(1).w的颜色为红 
     此时x的父结点一定是黑色的，我们可以通过将w染成黑色，x的父结点染成红色，然后对x的父结点进行左旋变成下面w为黑的情况(旋转以后要重新指定w)。变化为(2)的问题。

(2).w的颜色为黑 
     此时又需要按照w的左右儿子的颜色进行分类讨论 
1).w的左右儿子都为黑色：此时我们可以将w染成红色，x移动为x的父结点，将x在树中上移一层,如果x->p是根结点或x->p原来是红色则结束循环,否         则转成情况(1). 
2).w的右儿子为黑(左孩子为红)：此时我们可以通过染色和选择转成w的右孩子为红的情况(具体的操作见代码) 变化为4 的情况 继续执行
3).w的右儿子为红：这种情况下，我们是可以通过选择和染色去掉x的双重黑色，结束循环的(具体操作见代码) 4变化以后 结束循环

至此我们就将调整函数中所有的情况讨论完了，下面给出调整函数的代码：

///红黑树删除调整函数
///这个函数主要要解决的问题是x被染成红黑色,或是双重黑色的问题
///对于第一种情况只要简单的去掉x的红色就行了。
///对于第二种情况我们分情况讨论，将双重黑色的结点在树中上升
///直到转成情况1,或是上升为根结点
void RBDeleteFixUp(RBTree &x)
{
    while(x !=rt &&x->color == BLACK)
    {
        if(x == x->p->left)///按x是其父结点的左/右孩子分情况讨论
        {///下面的过程要按其兄弟结点的颜色进行分类讨论
            RBTree w=x->p->right; ///其兄弟结点
            
            ///Case 1
            if(w->color==RED)///如果兄弟结点是红色
            {///此时父结点一定是黑色；在保证黑高的情况下
                ///我们通过染色和旋转转成下面兄弟结点为黑色的情况
                
                w->color=BLACK;
                x->p->color=RED;
                LeftRotate(x->p);
                w=x->p->right;
            }
            
            ///Case 2
            if(w->left->color==BLACK&&w->right->color==BLACK)
            {///通过染色将x上移一层
                w->color=RED;
                x=x->p; ///将x在树中上移一层,如果x->p是根结点或x->p原来是红色则结束循环,否则转成情况1
            }
            else ///情况3,4
            {
                ///Case 3
                if(w->right->color==BLACK)
                {///染色和右旋成情况4
                    
                    w->color=RED;
                    w->left->color=BLACK;
                    RightRotate(w);
                    w=x->p->right;
                }
                ///Case 4
                ///情况4可以直接结束递归
                w->color=w->p->color;
                w->p->color=BLACK;
                w->right->color=BLACK; ///需要将w的右儿子染成黑色以保证黑高
                LeftRotate(x->p);
                break;
            }
        }
        else ///处理x是父结点的右儿子的情况
        {
            RBTree w=x->p->left;
            if(w->color==RED)///Case 1
            {
                w->p->color=RED;
                w->color=BLACK;
                RightRotate(x->p);
                w=x->p->left;
            }
            else if(w->left->color==BLACK&&w->right->color==BLACK)
            {///Case 2
                w->color=RED;
                x=x->p;
            }
            else
            {
                if(w->left->color==BLACK)///Case 3
                {
                    w->right->color=BLACK;
                    w->color=RED;
                    LeftRotate(w);
                    w=x->p->left;
                }
                w->color=x->p->color;///Case 4
                x->p->color=BLACK;
                w->left->color=BLACK;
                RightRotate(x->p);
                break
            }
        }
    }
    //解决红黑问题
    x->color=BLACK;
}

下面给出一份带注释和 测试 数据的完整红黑树代码： 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define RED 1
#define BLACK 0
///红黑树结点定义,与普通的二叉树搜索树相比多了一个颜色域
typedef struct node
{
    int key,color; ///定义1为红,0为黑
    node *p,*left,*right;
    node()
    {
        color=BLACK; ///默认结点颜色为黑
        p = NULL;
        left = NULL;
        right = NULL;
    }
}*RBTree;

RBTree Nul;///表示空的哨兵结点
RBTree  root; ///表示根结点

///左旋:对具有任意具有右孩子的结点可以进行
///传入要选择的结点指针的引用
///旋转以后x的右孩子y取代了x,而x成为y的左孩子,y的左孩子成为x的右孩子
///下面的代码就是完成这三个部分
void LeftRotate(RBTree x)
{
    RBTree y=x->right; ///y表示x的右孩子
    x->right=y->left; ///第一步:将x的右孩子设为y的左孩子
    if(y->left!=Nul)
        y->left->p=x;

    y->p=x->p;  ///更改y的父结点为x的父结点
    if(x->p==Nul)    ///第二步:y替代x,需要分情况讨论
        root=y; ///x原来是根结点,则设y为根结点
    else if(x==x->p->left)
        x->p->left=y;   ///更改y为x父结点的左孩子
    else
        x->p->right=y; ///更改y为x父结点的右孩子

    y->left=x; ///第三步:将x设为y的左孩子
    x->p=y;
}

///右旋:对任何具有左孩子的结点可以进行
///传入要右旋的结点指针的引用
///旋转以后结点x被左孩子y替换,x成为y的右儿子,y的右孩子成为x的左孩子
void RightRotate(RBTree x)
{
    RBTree y=x->left; ///y表示x的左孩子
    x->left=y->right; ///第一步:x的左孩子更改为y的右孩子
    if(y->right!=Nul)
        y->right->p=x;

    y->p=x->p;  ///更改y的父结点为x的父结点
    if(x->p==Nul) ///第二步:y替代x,需要分情况讨论
        root=y;  ///x原来为根结点,指定y为新根结点
    else if(x==x->p->left)
        x->p->left=y;  ///更改x父结点的左孩子为y
    else
        x->p->right=y; ///更改x父结点的右孩子为y

    y->right=x; ///第三步:更改y的右结点为x
    x->p=y;
}

///红黑树插入调整函数
///我们将插入结点染成红色,可能违反了性质4,所以要进行调整
///调整的过程其实就是根据不同的情况进行分类讨论,不断转换的过程
///最后转成可以通过染色和旋转恢复性质的情况
void RBInsertFixUp(RBTree z)
{
    ///在下面的代码中z结点总是违反性质4的那个结点
    while(z->p->color==RED) ///x是红色,它的父结点也是红色就说明性质4被违反,要持续调整
    {
        ///下面的过程按x->p是其祖父结点的左孩子还是右儿子进行分类讨论
        if(z->p==z->p->p->left) ///父结点是其祖父结点的左孩子
        {
            RBTree y=z->p->p->right;  ///表示z的叔结点
            ///下面按y的颜色进行分类讨论
            if(y->color==RED)
            {///如果y是红色并z的祖父结点一定是黑色的,这时我们通过下面的染色过程
                ///在保证黑高不变的情况下(性质5),将z在树中上移两层,z=z->p->p
                z->p->color=BLACK;
                y->color=BLACK;
                z->p->p->color=RED;
                z=z->p->p;///如果上移到根节点或某个父结点不为红的结点就可以结束循环了
            }
            else   ///叔结点为黑色
            { ///此时要根据z是其父结点的左孩子还是右孩子进行分类讨论
                ///如果z是左孩子则可以直接可以通过染色和右旋来恢复性质
                ///如果z是右孩子则可以先左旋来转成右孩子的情况
                if(z==z->p->right)
                {
                    z=z->p;
                    LeftRotate(z); ///直接左旋
                }
                ///重新染色,再右旋就可以恢复性质
                z->p->color=BLACK;
                z->p->p->color=RED;
                RightRotate(z->p->p);
            }
        }
        else///父结点是祖父结点的右孩子
        {
            RBTree y=z->p->p->left;  ///叔结点
            if(y->color==RED)
            {
                z->p->color=BLACK;
                y->color=BLACK;
                z->p->p->color=RED;
                z=z->p->p;
            }
            else
            {///右儿子的时候可以直接左旋,重新调色恢复性质
                ///左儿子可以先右旋成右儿子再处理
                if(z==z->p->left)
                {
                    z=z->p;
                    RightRotate(z);
                }
                z->p->color=BLACK;
                z->p->p->color=RED;
                LeftRotate(z->p->p);
            }
        }
    }
    ///将根节点染成黑色，是必要的步骤；处理两种情况
    ///1.第一次插入根结点被染成红色的情况
    ///2.和在上面的循环中根节点可能被染成红色的情况
    root->color=BLACK;
}

///红黑树的插入
///RB插入函数与普通的BST的插入函数只是稍微有点不同
///我们将原来的null换成了Nul结点,然后对新加入的结点,染成红色
///然后调用RBInserootFixUp函数进行调整,使得红黑树的性质不被破坏
void RBInsert(int key)
{
    RBTree z=new node;
    z->color=RED;
    z->key=key;
    z->p=z->left=z->right=Nul;
    RBTree y=Nul;
    RBTree x=root;
    while(x!=Nul) ///按照二叉搜索树的性质寻找z的插入点
    {
        y=x;
        if(z->key<x->key)
            x=x->left;
        else
            x=x->right;
    }
    z->p=y;
    if(y==Nul)///插入的是根节点
        root=z;
    else if(z->key<y->key)
        y->left=z;
    else
        y->right=z;
    RBInsertFixUp(z); ///插入红色结点可能违反了红黑树的某些性质,调用调整函数进行调整
}

///红黑树替换函数,v替换u,与BST的类似
///只负责更改父结点的指向,左右儿子需要自己更改
void RBTransplant(RBTree u,RBTree v)
{
    if(u->p==Nul)
        root=v;
    else if(u==u->p->left)
        u->p->left=v;
    else
        u->p->right=v;
    v->p=u->p;
}

///红黑树后继查找函数
///按二叉搜索树的性质一直往左走
RBTree RBTreeMinMuM(RBTree x)
{
    if(x->left==Nul)
        return x;
    return RBTreeMinMuM(x->left);
}

///红黑树删除调整函数
///这个函数主要要解决的问题是x被染成红黑色,或是双重黑色的问题
///对于第一种情况只要简单的去掉x的红色就行了。
///对于第二种情况我们分情况讨论，将双重黑色的结点在树中上升
///直到转成情况1,或是上升为根结点
void RBDeleteFixUp(RBTree x)
{
    while(x!=root&&x->color==BLACK)
    {
        if(x==x->p->left)///按x是其父结点的左/右孩子分情况讨论
        {///下面的过程要按其兄弟结点的颜色进行分类讨论
            RBTree w=x->p->right; ///其兄弟结点
            ///Case 1
            if(w->color==RED)///如果兄弟结点是红色
            {///此时父结点一定是黑色；在保证黑高的情况下
                ///我们通过染色和旋转转成下面兄弟结点为黑色的情况
                w->color=BLACK;
                x->p->color=RED;
                LeftRotate(x->p);
                w=x->p->right;
            }
            ///Case 2
            if(w->left->color==BLACK&&w->right->color==BLACK)
            {///通过染色将x上移一层
                w->color=RED;
                x=x->p; ///将x在树中上移一层,如果x->p是根结点或x->p原来是红色则结束循环,否则转成情况1
            }
            else ///情况3,4
            {
                ///Case 3
                if(w->right->color==BLACK)
                {///染色和右旋成情况4
                    w->color=RED;
                    w->left->color=BLACK;
                    RightRotate(w);
                    w=x->p->right;
                }
                ///Case 4
                ///情况4可以直接结束递归
                w->color=w->p->color;
                w->p->color=BLACK;
                w->right->color=BLACK; ///需要将w的右儿子染成黑色以保证黑高
                LeftRotate(x->p);
                break;
            }
        }
        else ///处理x是父结点的右儿子的情况
        {
            RBTree w=x->p->left;
            if(w->color==RED)
            {
                w->p->color=RED;
                w->color=BLACK;
                RightRotate(x->p);
                w=x->p->left;
            }
            else 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;
                    LeftRotate(w);
                    w=x->p->left;
                }
                w->color=x->p->color;
                x->p->color=BLACK;
                w->left->color=BLACK;
                RightRotate(x->p);
                break;
            }
        }
    }
    x->color=BLACK;
}

//红黑树删除函数
///类似于二叉树删除函数,不过在删除完成以后需要调用调整函数恢复性质
///总的过程也是按z的左右儿子情况进行分类.
///1.z只有左儿子/右儿子
///2.z有左右儿子,z的后继结点是z的右儿子
///3.z有左右儿子,z的后继结点不是z的右儿子
void RBDelete(RBTree &z)
{ ///在下面的过程中y总是指向树中会被删除的结点或是会被替代的结点
    ///x总是指向要替代z或y的结点

    RBTree x=Nul;
    RBTree y=z;
    int ycolor=y->color; ///记录y原来的颜色
    if(z->left==Nul) ///只有右儿子
    {
        x=z->right;
        RBTransplant(z, z->right);// z->right 替换 z
    }
    else if(z->right==Nul) ///只有左儿子
    {
        x=z->left;
        RBTransplant(z, z->left);
    }
    else  ///左右儿子都有
    {
        y=RBTreeMinMuM(z->right); ///查找z的后继
        ycolor=y->color;
        x=y->right; ///因为后面y会被染成z原来的颜色,所以违反性质的就是y的右儿子
        if(y->p==z) ///y是z的孩子结点
        {
            x->p=y;///这种情况下,y为x的父结点

            RBTransplant(z,y); ///y取代z
            y->left=z->left; ///z的左孩子改变指向
            y->left->p=y;
            y->color=z->color; ///更改y的颜色,这样的话从y以上红黑树的性质都不会违反
        }
        else ///y不是z的孩子结点的情况
        {
            RBTransplant(z, y); ///y取代z
            y->left=z->left; ///z的左孩子改变指向
            y->left->p=y;
            y->color=z->color; ///更改y的颜色,这样的话从y以上红黑树的性质都不会违反
            y->right=z->right;
            y->right->p=y;
            RBTransplant(y, y->right);
        }
    }
    //delete z;//
    ///如果y原来的颜色是黑色,那么就意味着有一个黑色结点被覆盖了,
    ///红黑树的性质可能会被破坏(性质4或5),需要调整
    if(ycolor==BLACK)
    {
        RBDeleteFixUp(x);
    }
}

///红黑树的中序遍历
void RBInoderSearch(RBTree x)
{
    if(x==Nul)
        return ;
    RBInoderSearch(x->left);
    printf("%d ",x->key);
    RBInoderSearch(x->right);
}

///通过关键字搜索对应结点
RBTree searchByKey(RBTree x,int k)
{
    if(x->key==k)
        return  x;
    if(k<x->key)
        return searchByKey(x->left,k);
    else
        return searchByKey(x->right,k);
    return NULL;
}

int main()
{
    int a[10]={1,134,21,235,318,12,34,3,99,198};
    Nul=new node;
    root=Nul;
    for(int i=0;i<10;i++)
    {
        RBInsert(a[i]);
        cout<<"after insert "<<a[i]<<": ";
        RBInoderSearch(root);
        cout<<endl;
    }
    cout<<endl;
    RBInoderSearch(root);
    cout<<endl<<endl;
    for(int i=0;i<10;i++)
    {
        RBTree x=searchByKey(root,a[i]);
        RBDelete(x);
        cout<<"after delete "<<a[i]<<": "<<endl;
        RBInoderSearch(root);
        cout<<endl;
    }
    return 0;
}



SoWhat1412
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
【Java】红黑树的删除操作概述和代码实现
weixin_44836685的博客
07-15 449
删除操作概述： 红黑树的删除操作相比于它的插入操作还是比较复杂的，一共涉及到了四种调整的情况，其核心就是因为删除了节点（黑），要保持每条路径上的黑色节点个数相等。 当删除节点为红色时，不用做任何调整；当删除节点时黑色，但它的孩子为红色时，直接把它的孩子变成黑色补上去。 删除情况调整（看兄弟）： 1、删除的时黑色节点，它的孩子也是黑色（或null），它的兄弟节点也是黑色：把兄弟节点变成黑色，指针指向...
红黑树（删除）
Hensonli的博客
05-01 2391
红黑树（删除） 我们在给红黑树插入一个节点的时候我们走的是先插入然后再调整颜色这一路线。这里我们在给红黑树进行删除某一个节点的时候也一样走的是先删除某一个节点，然后对红黑树的颜色进行调整的路线。 那么要在红黑树上删除某一个节点，那我们首先就要知道在二叉排序树上是怎样删除一个节点的。 二叉排序树删除某一个节点 假设我们要在红黑树中删除某一个节点z，那在我们删除节点z之后肯定要找另外一个节点来顶替我们删除掉的z节点。而寻找z节点的顶替节点需要根据z的孩子节点的不同情况来进行挑选，有下面这四种情况： 情况1 z节
红黑树插入与删除
10-11
主要讲述红黑树的插入、查找、删除、并设计了测试程序去测试程序的正确性
RBTree的删除
qq_55439426的博客
09-05 532
over and over
红黑树的旋转、查找和删除（附源代码）
airfish20000的博客
02-01 834
Red Black Tree Basic 红黑树的节点声明，其中Parent指针是指向某一节点的父节点的指针： typedef struct TreeNode *PtrRBTNode; typedef struct TreeNode RBTNode; struct TreeNode{ ElementType Key; ColorType Color;
第102篇 C++数据结构（十二）红黑树的删除
weixin_49188222的博客
05-19 721
第102篇 C++数据结构（十二）红黑树的删除红黑树删除的结点孩子情况红黑树的删除代码实现红黑树删除被删除结点的情况红黑树删除的调整红黑树删除的代码实现红黑树删除总结 红黑树删除的结点孩子情况 红黑树的删除和普通的二叉搜索树的删除时一样的，都是存在三种情况： 1.删除的结点没有孩子，这时这个结点可以直接删除 2.删除的结点有一个孩子，则用孩子的数据来替换掉它的数据，像数组的删除用后面的数据把前面的数据覆盖掉一样，然后删除该结点 3.删除的结点有两个孩子，这种情况可以转成（1），（2）情况，就是找前驱结点或者
使用C语言实现的rbtree红黑树.zip
03-21
红黑树 使用C语言实现的rbtree红黑树
使用C++实现的rbtree红黑树.zip
03-21
红黑树 使用C++实现的rbtree红黑树
使用Java语言实现的rbtree红黑树.zip
最新发布
03-21
红黑树 使用Java语言实现的rbtree红黑树
linux kernel中的红黑树及红黑树测试代码移植
08-11
可以用来研究红黑树代码，已经在项目中使用。附上运行结果 xw@xw-virtual-machine:~/share/test/rbtree$ ./rbtest KERN_ALERT rbtree testing key=1 key=2 key=3 key=4 key=5 key=6 key=7 key=8 key=9 key=10 erase ...
红黑树插入以及删除代码
08-31
红黑树插入删除代码，一些关键地方有打注释，比较好理解 删除部分可以配合http://sunblog.72pines.com/rb-tree-erase/看
红黑树 rbtree
02-10
非常好用的红黑树，下载直接使用，每次获取树最左边节点从而得到，最小node节点。
红黑树之删除原理和实现
weixin_30448685的博客
06-02 97
删除 因为根据BST中的规则，选择该结点的左子树中最大值和右子树中最小值替代掉原本要删除的点的值，再将改点删掉即可，所以这里只会讨论那个删掉的点。 分为以下情况： 删除结点的左右子结点均为空，则将其直接删除即可； 删除结点的左右子结点其中一方为空，则将存在的那一方的子结点替代掉删除结点即可。 删除结点的左右子结点均不为空，首先选择该结点的替代结点（可以是其左子树中的最大值，也可以是其右子树中的最...
RBTree（Insert & Delete)
Case
03-20 1336
　　这个红黑树想了很久，特别在做删除时候，搞不懂《算法导论》里面那个ｘ是什么东西，最后想了很久，最终才知道那个ｘ原来是删除后的节点的候补节点，ｙ是被删除的节点，我在做这个程序的时候可能跟《算法导论》的处理有点不同，它里面的ＮＵＬＬ节点与我的处理好象不一样（反正我看得不是很懂) ，我对于那个NULL节点，是在deletefixup里面new两个新的节点，不断的通过检测是否为空，来将其赋值，然后在每次
红黑树插入操作和删除的代码
Faded0104的博客
07-15 362
头文件：RBTree.h #pragma once typedef int Type; typedef enum{RED = 0,BLACK}COLOR; typedef struct RBNode { COLOR color; Type data; struct RBNode *parent; struct RBNode *leftChild; struct RBNode *r
红黑树remove操作
长期更新Java自学笔记
09-13 876
如果删除的是1个红色节点（父亲和孩子肯定是黑色），不影响该路径上黑色节点的数量，也不会导致删除后的红黑树出现连续两个红色节点的情况，所以不做任何调整工作如果删除的是1个黑色节点，那经过被删除节点的路径就会比其他路径上的黑色节点少一个，需要把被删除节点的孩子补上来，分2种情况：如果补上来的孩子是红色节点，直接把这个孩子涂成黑色， 调整完成如果补上来的孩子是黑色节点，那在当前的路径上没办法再补一个黑色节点出来了，只能从兄弟那里借调黑色节点，再分4种情况我们现在要删除B节点B以及B的孩子NULL是黑色的，删除B后
红黑树的构建与删除
keaiduo_sensen的博客
03-12 628
红黑树是一种特殊的二叉搜索树。 其特点是：节点中含有一个记录颜色的标记位，可以是Red或Black中的任意一种颜色。通过对每条从根节点到空节点的路径上的节点的颜色进行限制，红黑树确保没有一条路径会比其他路径长出两倍(最长路径不会超过最短路径的两倍)，因此红黑树的高度接近平衡。
红黑树原理及代码实现(删除部分)（二）
旧时明月丶
10-07 312
上一篇讲了红黑树，只讲到了红黑树添加节点，这一篇来讲讲红黑树的删除。不得不说红黑树的删除真的是太太复杂了，我是肝了好几个星期，网上找遍了资料，也没有几个能读懂的，后来结合源码，终于是对红黑树的删除有了一些基本的理解。 先奉上一个红黑树大图，用于参照，便于后面的理解： 删除 红黑树的删除其实就是一个穷举的过程，把节点每一种的情况都考虑一遍，然后尽可能的简化操作，达到代码的精简。对待删除节点的不同状态，可以分成三个大类： 1.待删除节点没有子节点 2.待删除节点只有一个子节点 3.待删除节点有两个子节点 当待
红黑树插入与删除 算法实现+代码（二）
Norton的专栏
04-04 2117
如下图， 如上图，
c语言红黑树代码
05-29
以下是一个简单的 C 语言红黑树代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义红黑树节点结构体 typedef struct RBNode { int data; int color; struct RBNode *left; struct RBNode *right; struct RBNode *parent; } RBNode; // 定义红黑树结构体 typedef struct RBTree { RBNode *root; } RBTree; // 定义常量 #define RED 0 #define BLACK 1 // 初始化红黑树 void init(RBTree *tree) { tree->root = NULL; } // 树的左旋操作 void leftRotate(RBTree *tree, RBNode *node) { RBNode *right = node->right; node->right = right->left; if (right->left != NULL) { right->left->parent = node; } right->parent = node->parent; if (node->parent == NULL) { tree->root = right; } else if (node == node->parent->left) { node->parent->left = right; } else { node->parent->right = right; } right->left = node; node->parent = right; } // 树的右旋操作 void rightRotate(RBTree *tree, RBNode *node) { RBNode *left = node->left; node->left = left->right; if (left->right != NULL) { left->right->parent = node; } left->parent = node->parent; if (node->parent == NULL) { tree->root = left; } else if (node == node->parent->right) { node->parent->right = left; } else { node->parent->left = left; } left->right = node; node->parent = left; } // 插入节点 void insert(RBTree *tree, int data) { RBNode *node = (RBNode *)malloc(sizeof(RBNode)); node->data = data; node->color = RED; node->left = NULL; node->right = NULL; node->parent = NULL; RBNode *parent = NULL; RBNode *current = tree->root; while (current != NULL) { parent = current; if (node->data < current->data) { current = current->left; } else { current = current->right; } } node->parent = parent; if (parent == NULL) { tree->root = node; } else if (node->data < parent->data) { parent->left = node; } else { parent->right = node; } while (node != tree->root && node->parent->color == RED) { if (node->parent == node->parent->parent->left) { RBNode *uncle = node->parent->parent->right; if (uncle != NULL && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->right) { node = node->parent; leftRotate(tree, node); } node->parent->color = BLACK; node->parent->parent->color = RED; rightRotate(tree, node->parent->parent); } } else { RBNode *uncle = node->parent->parent->left; if (uncle != NULL && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->left) { node = node->parent; rightRotate(tree, node); } node->parent->color = BLACK; node->parent->parent->color = RED; leftRotate(tree, node->parent->parent); } } } tree->root->color = BLACK; } // 中序遍历 void inorder(RBNode *node) { if (node != NULL) { inorder(node->left); printf("%d ", node->data); inorder(node->right); } } int main() { RBTree tree; init(&tree); insert(&tree, 10); insert(&tree, 20); insert(&tree, 30); insert(&tree, 15); insert(&tree, 18); insert(&tree, 25); insert(&tree, 5); inorder(tree.root); return 0; } ``` 这段代码使用了结构体定义红黑树节点和红黑树，以及一些常量和函数来实现红黑树的插入和中序遍历操作。代码中的 `insert` 函数使用了红黑树的插入算法来插入新的节点，并维护红黑树的性质。在 `main` 函数中，我们插入了一些数据并进行了中序遍历操作，以验证红黑树的正确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SoWhat1412

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值