CLRS 13.4删除

最新推荐文章于 2023-04-22 23:15:00 发布
最新推荐文章于 2023-04-22 23:15:00 发布
阅读量513 收藏
点赞数
分类专栏： 算法导论 文章标签： clrs 红黑树 删除
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012593447/article/details/48751295
版权

13.4-1
首先，情况 1 会转变为情况 2、3、4，所以接下来讨论情况 2、3、4。
情况 2 中，如新的 x 结点变成根，则退出循环然后将根结点着成黑色，否则会继续向上保持循环；
情况 3 会转变为情况 4，对于情况 4，会将 x 设为根，然后退出循环并将根着成黑色。
综上可知树根一定是黑色的。

13.4-2
如果 x 和 x.p 都是红色，显然调用RB-DELETE-FIXUP不会进人循环，直接将 x 着成黑色。

13.4-3
这里写图片描述

13.4-4
在RB-DELETE中的结点 y 没有孩子时，那么结点 x=T.nil ，因此RB-DELETE-FIXUP的第 2 行会检查。
当删除根结点时 x=T.nil 并且此时的根是 x ，在RB-DELETE-FIXUP的第 23 会将 x 着成黑色。

13.4-5
情况 1：转换前根结点到子树 α,β 的黑结点数是 3（结点 x 是双黑），到 γ,δ,ϵ,ζ 都是 2。转换后根结点到子树 α,β 的黑结点数是 3，到 γ,δ,ϵ,ζ 都是 2。

情况 2：转换前根结点到子树 α,β,γ,δ,ϵ,ζ 的黑结点数是 2+count(c)。转换后新结点 x 有一个属性值 c，它是红黑或者双黑。若转换前是红色，那么原count(c)=0，转换后count(c)=1，否则原count(c)=1，转换后count(c)=2，因此转换后根结点到子树 α,β,γ,δ,ϵ,ζ 的黑结点数没变。

情况 3、4 可以根据情况 2 类似得到，在此略。

13.4-6
情况 1 发生时， x 的兄弟结点 w 是红色，如果 x.p 是红色，也就是 w.p 是红色，此时已经违反了红黑树的性质，我们都不可能调用RB-DELETE。

13.4-7
可能一样也可能不一样，下面给两个简单的例子，例一是树形改变，例二是树形一样但结点颜色变化。

这里写图片描述

附上红黑树代码（注释很少，基本上和书上的伪代码一样，看得懂伪代码应该就能看懂下面的代码）。

#include <iostream>
#include <climits>
#include <iomanip>
using std::cout;
using std::endl;

enum COLOR
{
    RED = 0,BLACK = 1
};

struct RB_TREE
{
    int key;
    COLOR color;
    RB_TREE *parent;
    RB_TREE *left;
    RB_TREE *right;
};

RB_TREE nil = {INT_MIN,BLACK,NULL,NULL,NULL};//简单初始化一下哨兵，其实能用到的只是哨兵的颜色

void LEFT_ROTATE(RB_TREE **root,RB_TREE *x)
{
    if(x->right != &nil)    //x的右孩子为哨兵，直接返回
    {
        RB_TREE *y = x->right;
        x->right = y->left;
        if(y->left != &nil)
            y->left->parent = x;
        y->parent = x->parent;
        if(x->parent == &nil)
            *root = y;
        else if(x == x->parent->left)
            x->parent->left = y;
        else x->parent->right = y;
        y->left = x;
        x->parent = y;
    }
    else return;
}

void RIGHT_ROTATE(RB_TREE **root,RB_TREE *x)
{
    if(x->left != &nil)
    {
        RB_TREE *y = x->left;
        x->left = y->right;
        if(y->right != &nil)
            y->right->parent = x;
        y->parent = x->parent;
        if(x->parent == &nil)
            *root = y;
        else if(x == x->parent->left)
            x->parent->left = y;
        else x->parent->right = y;
        y->right = x;
        x->parent = y;
    }
}

RB_TREE *SEARCH(RB_TREE *root,int key)
{
    if(root == &nil || root->key == key)
        return root;
    else if(root->key > key)
        return SEARCH(root->left,key);
    else return SEARCH(root->right,key);
}

RB_TREE *MINIMUM(RB_TREE *root)
{
    if(root == &nil || root->left == &nil)
        return root;
    else return MINIMUM(root->left);
}

RB_TREE *MAXIMUM(RB_TREE *root)
{
    if(root == &nil || root->right == &nil)
        return root;
    else return MAXIMUM(root->right);
}

RB_TREE *SUCCESSOR(RB_TREE *p)
{
    if(p == &nil)
        return p;
    if(p->right != &nil)
        return MINIMUM(p->right);
    RB_TREE *x = p->parent;
    while(x != &nil && p == x->right)
    {
        p = x;
        x = x->parent;
    }
    return x;
}

RB_TREE *PREDECESSOR(RB_TREE *p)
{
    if(p == &nil)
        return p;
    if(p->left != &nil)
        return MAXIMUM(p->left);
    RB_TREE *x = p->parent;
    while(x != &nil && p == x->left)
    {
        p = x;
        x = x->parent;
    }
    return x;
}

void RB_INSERT_FIXUP(RB_TREE **root,RB_TREE *z)
{
    while(z->parent->color == RED)
    {
        if(z->parent == z->parent->parent->left)
        {
            RB_TREE *y = z->parent->parent->right;
            if(y->color == RED)
            {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else
            {
                if(z == z->parent->right)
                {
                    z = z->parent;
                    LEFT_ROTATE(root,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                RIGHT_ROTATE(root,z->parent->parent);
            }
        }
        else
        {
            RB_TREE *y = z->parent->parent->left;
            if(y->color == RED)
            {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else
            {
                if(z == z->parent->left)
                {
                    z = z->parent;
                    RIGHT_ROTATE(root,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                LEFT_ROTATE(root,z->parent->parent);
            }
        }
    }
    (*root)->color = BLACK;
}

void RB_INSERT(RB_TREE **root,int key)
{
    RB_TREE *y = &nil;
    RB_TREE *x = *root;
    while(x != &nil)
    {
        y = x;
        if(x->key > key)
            x = x->left;
        else x = x->right;
    }
    RB_TREE *z = new RB_TREE;
    z->parent = y;
    if(y == &nil)
        *root = z;
    else if(key < y->key)
        y->left = z;
    else y->right = z;
    z->key = key;
    z->left = z->right = &nil;
    z->color = RED;
    RB_INSERT_FIXUP(root,z);
}

void RB_TRANSPLANT(RB_TREE **root,RB_TREE *u,RB_TREE *v)
{
    if(u->parent == &nil)
        *root = v;
    else if(u == u->parent->left)
        u->parent->left = v;
    else u->parent->right = v;
    v->parent = u->parent;
}

void RB_DELETE_FIXUP(RB_TREE **root,RB_TREE *x)
{
    while(x != *root && x->color == BLACK)
    {
        if(x == x->parent->left)
        {
            RB_TREE *w = x->parent->right;
            if(w->color == RED)
            {
                w->color = BLACK;
                x->parent->color = RED;
                LEFT_ROTATE(root,x->parent);
                w = x->parent->right;
            }
            if(w->left->color == BLACK && w->right->color == BLACK)
            {
                w->color = RED;
                x = x->parent;
            }
            else
            {
                if(w->right->color == BLACK)
                {
                    w->left->color = BLACK;
                    w->color = RED;
                    RIGHT_ROTATE(root,w);
                    w = x->parent->right;
                }
                w->color = x->parent->color;
                x->parent->color = BLACK;
                w->right->color = BLACK;
                LEFT_ROTATE(root,x->parent);
                x = *root;
            }
        }
        else
        {
            RB_TREE *w = x->parent->left;
            if(w->color == RED)
            {
                w->color = BLACK;
                x->parent->color = RED;
                RIGHT_ROTATE(root,x->parent);
                w = x->parent->left;
            }
            if(w->left->color == BLACK && w->right->color == BLACK)
            {
                w->color = RED;
                x = x->parent;
            }
            else
            {
                if(w->left->color == BLACK)
                {
                    w->right->color = BLACK;
                    w->color = RED;
                    LEFT_ROTATE(root,w);
                    w = x->parent->left;
                }
                w->color = x->parent->color;
                x->parent->color = BLACK;
                w->left->color = BLACK;
                RIGHT_ROTATE(root,x->parent);
                x = *root;
            }
        }
    }
    x->color = BLACK;
}

void RB_DELETE(RB_TREE **root, int key)
{
    RB_TREE *z = SEARCH(*root,key);
    if(z == &nil)
        return;
    RB_TREE *y = z;
    COLOR y_original_color = y->color;
    RB_TREE *x;
    if(z->left == &nil)
    {
        x = z->right;
        RB_TRANSPLANT(root,z,z->right);
    }
    else if(z->right == &nil)
    {
        x = z->left;
        RB_TRANSPLANT(root,z,z->left);
    }
    else
    {
        y = MINIMUM(z->right);
        y_original_color = y->color;
        x = y->right;
        if(y->parent == z)
            x->parent = y;
        else
        {
            RB_TRANSPLANT(root,y,y->right);
            y->right = z->right;
            y->right->parent = y;
        }
        RB_TRANSPLANT(root,z,y);
        y->left = z->left;
        y->left->parent = y;
        y->color = z->color;
    }
    if(y_original_color == BLACK)
        RB_DELETE_FIXUP(root,x);
    delete z;
}

void preOrder(RB_TREE *root)
{
    if(root != &nil)
    {
        cout << "key is: " << std::setw(3) << root->key << ' ' << " and color is: ";
        if(root->color == BLACK)
            cout << "BLACK" << endl;
        else cout << "RED" << endl;
        preOrder(root->left);
        preOrder(root->right);
    }
}

void inOrder(RB_TREE *root)
{
    if(root != &nil)
    {
        inOrder(root->left);
        cout << "key is: " << std::setw(3) << root->key << ' ' << " and color is: ";
        if(root->color == BLACK)
            cout << "BLACK" << endl;
        else cout << "RED" << endl;
        inOrder(root->right);
    }
}

void postOrder(RB_TREE *root)
{
    if(root != &nil)
    {
        postOrder(root->left);
        postOrder(root->right);
        cout << "key is: " << std::setw(3) << root->key << ' ' << " and color is: ";
        if(root->color == BLACK)
            cout << "BLACK" << endl;
        else cout << "RED" << endl;
    }
}

int main()
{
    int ia[] = {41,38,31,12,19,8};
    RB_TREE *root = &nil;
    for(int i = 0; i < 6; ++i)       //创建红黑树
        RB_INSERT(&root,ia[i]);
    cout << "preOder is" << endl;
    preOrder(root);
    cout << endl;
    cout << "inOder is" << endl;
    inOrder(root);
    cout << endl;
    cout << "postOder is" << endl;
    postOrder(root);
    cout << endl;

    RB_DELETE(&root,8);              //删除关键字8的结点
    cout << "after delete key 8:" << endl;
    cout << "preOder is" << endl;
    preOrder(root);
    cout << endl;
    cout << "inOder is" << endl;
    inOrder(root);
    cout << endl;
    cout << "postOder is" << endl;
    postOrder(root);
    cout << endl;

    RB_DELETE(&root,12);             //删除关键字12的结点
    cout << "after delete key 12:" << endl;
    cout << "preOder is" << endl;
    preOrder(root);
    cout << endl;
    cout << "inOder is" << endl;
    inOrder(root);
    cout << endl;
    cout << "postOder is" << endl;
    postOrder(root);
    cout << endl;

    RB_DELETE(&root,19);              //删除关键字19的结点
    cout << "after delete key 19:" << endl;
    cout << "preOder is" << endl;
    preOrder(root);
    cout << endl;
    cout << "inOder is" << endl;
    inOrder(root);
    cout << endl;
    cout << "postOder is" << endl;
    postOrder(root);

    cout << endl;
    return 0;
}
昵称怎么会存在
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论 第13章 红黑树
幸福在路上
07-08 9686
一、概念 1.定义与性质 （1）定义 红黑树字义：满足(a)每个结点或是红的，或是黑的(b)根结点是黑的(c)每个叶结点（NIL）是黑的(d)如果一个结点是红的，则它的两个儿子是黑的(e)对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点的二叉查找树称为红黑树。 黑高度定义：从某个结点x出发（不包括该结点）到达一个叶结点的任意一条路径上的黑色结点的个数称为x的黑高度。 （2
红黑树--删除 算法导论笔记
qq1519932709的专栏
05-19 591
红黑树的删除与插入一样，需要花费时间O(lg n)。但比插入操作要复杂些。   在红黑树的删除z时，其基本思路是： 1.如果z没有左孩子，则用z右孩子替换z； 2.如果z没有右孩子，则用z左孩子替换z； 3.z的左右子树均不为空，则选出z右子树中最小后代（最左节点）。用该节点替换z。 最后，再对该树进行调整。
Message/Folder primer13章
weixin_34227447的博客
06-28 110
1 #include<string> 2 #include<iostream> 3 #include<set> 4 class Folder; 5 class Message; 6 7 class Folder 8 { 9 public: 10 void delete_mess(Messag...
13.4
qq_36687355的博客
04-16 91
//abc.h #ifndef ABC_H #define ABC_H #include&lt;iostream&gt; class ABC{ private: char* label; int rating; public: ABC(const char* l="null",int r=0); ABC(const ABC&amp; a); virtual ~ABC(); ABC...
第十三章 13.1.6节练习 & 13.2节练习
听枫烨阁的博客
09-11 1098
练习13.18 定义一个Employee类，
C++ primer 13.4消息处理
shuangyan5230的专栏
01-18 435
class CFolder; class CMessage { public: CMessage(const string &strMsg = ""); ~CMessage(); CMessage(const CMessage &); CMessage & operator=(const CMessage &rhs); void Save(CFolder &); void
CLRS第十三章思考题
我的专栏
01-28 364
思考题13-1
算法导论(CLRS）习题
最新发布
m0_65448233的博客
04-22 263
6.5-1 试说明 HEAP-EXTRACT-MAX 在堆 A={15,13,9,5,12,8,7,4,0,6,2,1} 上的操作过程。由 的伪代码和 MAX-HEAPIFY(A,i) ：通过不断交换 i 和其孩子数据，从而维持最大堆性质 可知，在堆A中，判空后记录下了max为15，将堆中最后一个元素 1 交换到根节点A[1]，堆的大小减一，然后执行 MAX-HEAPIFY(A,1) 即：1和13交换，1和12交换，1和6交换，最后返回max：15 7.1-1 参照图7-1的方法，说明PARTITIO
算法导论-第13章-红黑树
灯火阑珊处
11-05 658
一、概念 1.定义与性质 （1）定义 红黑树字义：满足(a)每个结点或是红的，或是黑的(b)根结点是黑的(c)每个叶结点（NIL）是黑的(d)如果一个结点是红的，则它的两个儿子是黑的(e)对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点的二叉查找树称为红黑树。 黑高度定义：从某个结点x出发（不包括该结点）到达一个叶结点的任意一条路径上的黑色结点的个数称为x的
CLRS英文第二版
08-04
CLRS英文第二版 .
clrs-mit-THIRD EDITION
06-15
指《算法导论》（Introduction to Algorithms）。 由Thomas H. Cormen，Charles E. Leiserson，Ronald L. Rivest，Clifford Stein编写，MIT出版的一本介绍、分析当代计算机...用四位作者姓的首字母组成的CLRS代表此书。
CLRS:CLRS 代码
06-26
《CLRS: CLRS 代码》是对计算机科学领域经典教材《算法导论》（英文原版为"Introduction to Algorithms"，通常简称CLRS，由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein合著）中的...
CLRS：算法入门第3版中的一些练习和问题
02-02
介绍 《算法导论》（CLRS）第三版中的一些练习和问题。 永远不要相信回购单字。 您可以使用 Chrome扩展程序读取。 如果Markdown和TeX的语法存在冲突，请告诉我是否格式错误。笔记本摘要我基础1算法在计算中的作用2...
CLRS 4.4用递归树方法求解递归式
热门推荐
我的专栏
08-21 1万+
练习4.4-1、4.4-2、4.4-3、4.4-4、4.4-5、4.4-6、4.4-7、4.4-8、4.4-8
CLRS 15.3动态规划原理
我的专栏
05-26 3986
练习15.3-1、15.3-2、15.3-3、15.3-4、15.3-5、15.3-6
CLRS 4.3用代入法求解递归式
我的专栏
08-19 3248
练习4.3-1、4.3-2、4.3-3、4.3-4、4.3-5、4.3-6、4.3-7、4.3-8、4.3-9
CLRS 9.3最坏情况为线性时间的选择算法
我的专栏
11-16 2197
练习9.3-1、9.3-2、9.3-3、9.3-4、9.3-5、9.3-6、9.3-7、9.3-8、9.3-9
《算法导论》第三版——CLRS解析
"clrs-mit-THIRD EDITION" 是关于《算法导论》(Introduction to Algorithms) 第三版的详细信息，这本书是由Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest 和 Clifford Stein 四位作者共同编写的。这四...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值