浅谈红黑树的添加删除操作

最新推荐文章于 2023-03-01 07:45:00 发布
置顶 最新推荐文章于 2023-03-01 07:45:00 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： Data Structure 文章标签： 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqp_ya_ping/article/details/51505740
版权

红黑树的性质（牢记）
1、每个结点的颜色只能是红色或黑色。
2、根结点必须是黑色的。
3、每个叶子结点都带有两个空的黑色结点（被称为黑哨兵null），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。
4、如果一个结点是红的，则它的两个儿子都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。
5、从任何一个结点到其子孙叶结点的所有路径上包含相同数目的黑结点。

一、红黑树的插入
任何一个即将插入的新结点的初始颜色都为红色。这一点很容易理解，因为插入黑点会增加某条路径上黑结点的数目，从而导致整棵树黑高度的不平衡。但如果新结点父结点为红色时（如图2所示），将会违返红黑树性质：一条路径上不能出现相邻的两个红色结点。这时就需要通过一系列操作来使红黑树保持平衡。

注：“新”字表示一个新插入的结点；使用“父”字表示新插入点的父结点；使用“叔”字表示“父”结点的兄弟结点；使用“祖”字表示“父”结点的父结点。

1、 黑父
直接插入，不影响平衡。
2、 红父
叔父结点为红色时，无需进行旋转操作，只要将父和叔结点变为黑色，将祖父结点变为红色即可（当祖父节点为根节点时务必改为黑节点，见性质2）。但由于祖父结点的父结点有可能为红色，从而违反红黑树性质。此时必须将祖父结点作为新的判定点继续向上进行平衡操作。
这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

*红黑树插入示例1
这里写图片描述
这里写图片描述

*红黑树插入示例2
这里写图片描述
这里写图片描述
这里写图片描述

二、红黑树的删除

红黑树上结点的删除
红黑树本身是一棵二叉查找树，它的删除和二叉查找树的删除类似。首先要找到真正的删除点，当被删除结点n存在左右孩子时，真正的删除点应该是n的中序遍在前驱，关于这一点请复习二叉查找树的删除。如图所示，当删除结点20时，实际被删除的结点应该为18，结点20的数据变为18。
这里写图片描述
所以可以推断出，在进行删除操作时，真正的删除点必定是只有一个孩子或没有孩子的结点。而根据红黑树的性质可以得出以下两个结论：
1、 删除操作中真正被删除的必定是只有一个红色孩子或没有孩子的结点。
2、 如果真正的删除点是一个红色结点，那么它必定是一个叶子结点。
在以下讨论中，真正的删除点使用“旧”标注，旧点所在位置将被它的的孩子结点所取代（最多只有一个孩子），我们使用“新”表示旧点的孩子结点。删除操作可分为以下几种情形：
1、旧点为红色结点

若旧点为红色结点，则它必定是叶子结点，直接删除即可。
这里写图片描述
2、一红一黑
当旧点为黑色结点，新点为红色结点时，将新点取代旧点位置后，将新点染成黑色即可。这里需要注意：旧点为红色，新点为黑色的情况不可能存在。
这里写图片描述
3、双黑

当旧点和新点都为黑色时（新点为空结点时，亦属于这种情况），情况比较复杂，需要根据旧点兄弟结点的颜色来决定进行什么样的操作。我们使用“兄”来表示旧点的兄弟结点。这里可分为红兄和黑兄两种情况：

3.1 红兄

由于兄弟结点为红色，所以父结点必定为黑色，而旧点被删除后，新点取代了它的位置。下图演示了两种可能的情况：
这里写图片描述
红兄的情况需要进行RR或LL型旋转，然后将父结点染成红色，兄结点染成黑色。然后重新以新点为判定点进行平衡操作。我们可以观察到，旋转操作完成后，判定点没有向上回溯，而是降低了一层，此时变成了黑兄的情况。

3.2 黑兄
黑兄的情况最为复杂，需要根据黑兄孩子结点（这里用“侄”表示）和父亲结点的颜色来决定做什么样的操作。

3.2.1 黑兄二黑侄红父
如图所示，这种情况比较简单，只需将父结点变为黑色，兄结点变为黑色，新结点变为黑色即可，删除操作到此结束。
这里写图片描述
3.2.2 黑兄二黑侄黑父
如图所示，此时将父结点染成新结点的颜色，新结点染成黑色，兄结点染成红色即可。当新结点为红色时，父结点被染成红色，此时需要以父结点为判定点继续向上进行平衡操作。
这里写图片描述

3.2.3 黑兄红侄

黑兄红侄有以下四种情形，下面分别进行图示：
情形1：
这里写图片描述
这里写图片描述
删除操作也可参考http://blog.csdn.net/goodluckwhh/article/details/12718233

//参考代码
#include "stdafx.h"
#define BLACK 1
#define RED 0
#include<iostream>
#include<string>
using namespace std;

class bst {
private:

    struct Node {
        int value;
        bool color;
        Node *leftTree, *rightTree, *parent;

        Node() {
            color = RED;
            leftTree = NULL;
            rightTree = NULL;
            parent = NULL;
            value = 0;
        }

        Node* grandparent() {
            if (parent == NULL) {
                return NULL;
            }
            return parent->parent;
        }

        Node* uncle() {
            if (grandparent() == NULL) {
                return NULL;
            }
            if (parent == grandparent()->rightTree)
                return grandparent()->leftTree;
            else
                return grandparent()->rightTree;
        }

        Node* sibling() {
            if (parent->leftTree == this)
                return parent->rightTree;
            else
                return parent->leftTree;
        }
    };

    void rotate_right(Node *p) {
        Node *gp = p->grandparent();
        Node *fa = p->parent;
        Node *y = p->rightTree;

        fa->leftTree = y;

        if (y != NIL)
            y->parent = fa;
        p->rightTree = fa;
        fa->parent = p;

        if (root == fa)
            root = p;
        p->parent = gp;

        if (gp != NULL) {
            if (gp->leftTree == fa)
                gp->leftTree = p;
            else
                gp->rightTree = p;
        }

    }

    void rotate_left(Node *p) {
        if (p->parent == NULL) {
            root = p;
            return;
        }
        Node *gp = p->grandparent();
        Node *fa = p->parent;
        Node *y = p->leftTree;

        fa->rightTree = y;

        if (y != NIL)
            y->parent = fa;
        p->leftTree = fa;
        fa->parent = p;

        if (root == fa)
            root = p;
        p->parent = gp;

        if (gp != NULL) {
            if (gp->leftTree == fa)
                gp->leftTree = p;
            else
                gp->rightTree = p;
        }
    }



    string outputColor(bool color) {
        return color ? "BLACK" : "RED";
    }   
    void inorder(Node *p) {
        string str;
        if (p == NIL)
            return;

        if (p->leftTree)
            inorder(p->leftTree);
        str = outputColor(p->color);
        cout << p->value << ":" << str << " ";

        if (p->rightTree)
            inorder(p->rightTree);
    }

    Node* getSmallestChild(Node *p) {
        if (p->leftTree == NIL)
            return p;
        return getSmallestChild(p->leftTree);
    }

    bool delete_child(Node *p, int data) {
        if (p->value > data) {
            if (p->leftTree == NIL) {
                return false;
            }
            return delete_child(p->leftTree, data);
        }
        else if (p->value < data) {
            if (p->rightTree == NIL) {
                return false;
            }
            return delete_child(p->rightTree, data);
        }
        else if (p->value == data) {
            if (p->rightTree == NIL) {
                delete_one_child(p);
                return true;
            }
            Node *smallest = getSmallestChild(p->rightTree);
            swap(p->value, smallest->value);
            delete_one_child(smallest);

            return true;
        }
    }

    void delete_one_child(Node *p) {
        Node *child = p->leftTree == NIL ? p->rightTree : p->leftTree;
        if (p->parent == NULL && p->leftTree == NIL && p->rightTree == NIL) {
            p = NULL;
            root = p;
            return;
        }

        if (p->parent == NULL) {
            delete  p;
            child->parent = NULL;
            root = child;
            root->color = BLACK;
            return;
        }

        if (p->parent->leftTree == p) {
            p->parent->leftTree = child;
        }
        else {
            p->parent->rightTree = child;
        }
        child->parent = p->parent;

        if (p->color == BLACK) {
            if (child->color == RED) {
                child->color = BLACK;
            }
            else
                delete_case(child);
        }

        delete p;
    }

    void delete_case(Node *p) {
        if (p->parent == NULL) {
            p->color = BLACK;
            return;
        }
        if (p->sibling()->color == RED) {
            p->parent->color = RED;
            p->sibling()->color = BLACK;
            if (p == p->parent->leftTree)
                rotate_left(p->sibling());
            else
                rotate_right(p->sibling());
        }
        if (p->parent->color == BLACK && p->sibling()->color == BLACK
            && p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
            p->sibling()->color = RED;
            delete_case(p->parent);
        }
        else if (p->parent->color == RED && p->sibling()->color == BLACK
            && p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
            p->sibling()->color = RED;
            p->parent->color = BLACK;
        }
        else {
            if (p->sibling()->color == BLACK) {
                if (p == p->parent->leftTree && p->sibling()->leftTree->color == RED
                    && p->sibling()->rightTree->color == BLACK) {
                    p->sibling()->color = RED;
                    p->sibling()->leftTree->color = BLACK;
                    rotate_right(p->sibling()->leftTree);
                }
                else if (p == p->parent->rightTree && p->sibling()->leftTree->color == BLACK
                    && p->sibling()->rightTree->color == RED) {
                    p->sibling()->color = RED;
                    p->sibling()->rightTree->color = BLACK;
                    rotate_left(p->sibling()->rightTree);
                }
            }
            p->sibling()->color = p->parent->color;
            p->parent->color = BLACK;
            if (p == p->parent->leftTree) {
                p->sibling()->rightTree->color = BLACK;
                rotate_left(p->sibling());
            }
            else {
                p->sibling()->leftTree->color = BLACK;
                rotate_right(p->sibling());
            }
        }
    }

    void insert(Node *p, int data) {
        if (p->value >= data) {
            if (p->leftTree != NIL)
                insert(p->leftTree, data);
            else {
                Node *tmp = new Node();
                tmp->value = data;
                tmp->leftTree = tmp->rightTree = NIL;
                tmp->parent = p;
                p->leftTree = tmp;
                insert_case(tmp);
            }
        }
        else {
            if (p->rightTree != NIL)
                insert(p->rightTree, data);
            else {
                Node *tmp = new Node();
                tmp->value = data;
                tmp->leftTree = tmp->rightTree = NIL;
                tmp->parent = p;
                p->rightTree = tmp;
                insert_case(tmp);
            }
        }
    }

    void insert_case(Node *p) {
        if (p->parent == NULL) {
            root = p;
            p->color = BLACK;
            return;
        }
        if (p->parent->color == RED) {
            if (p->uncle()->color == RED) {
                p->parent->color = p->uncle()->color = BLACK;
                p->grandparent()->color = RED;
                insert_case(p->grandparent());
            }
            else {
                if (p->parent->rightTree == p && p->grandparent()->leftTree == p->parent) {
                    rotate_left(p);
                    rotate_right(p);
                    p->color = BLACK;
                    p->leftTree->color = p->rightTree->color = RED;
                }
                else if (p->parent->leftTree == p && p->grandparent()->rightTree == p->parent) {
                    rotate_right(p);
                    rotate_left(p);
                    p->color = BLACK;
                    p->leftTree->color = p->rightTree->color = RED;
                }
                else if (p->parent->leftTree == p && p->grandparent()->leftTree == p->parent) {
                    p->parent->color = BLACK;
                    p->grandparent()->color = RED;
                    rotate_right(p->parent);
                }
                else if (p->parent->rightTree == p && p->grandparent()->rightTree == p->parent) {
                    p->parent->color = BLACK;
                    p->grandparent()->color = RED;
                    rotate_left(p->parent);
                }
            }
        }
    }

    void DeleteTree(Node *p) {
        if (!p || p == NIL) {
            return;
        }
        DeleteTree(p->leftTree);
        DeleteTree(p->rightTree);
        delete p;
    }
public:

    bst() {
        NIL = new Node();
        NIL->color = BLACK;
        root = NULL;
    }

    ~bst() {
        if (root)
            DeleteTree(root);
        delete NIL;
    }

    void inorder() {
        if (root == NULL)
            return;
        inorder(root);
        cout << endl;
    }

    void insert(int x) {
        if (root == NULL) {
            root = new Node();
            root->color = BLACK;
            root->leftTree = root->rightTree = NIL;
            root->value = x;
        }
        else {
            insert(root, x);
        }
    }

    bool delete_value(int data) {
        return delete_child(root, data);
    }
private:
    Node *root, *NIL;
};


int _tmain(int argc, _TCHAR* argv[])
{
    bst bt;
    int i,j;
    for (i = 0,j=21; i <= 3&&j>=18; i++,j--)
    {
        bt.insert(i);
        bt.insert(j);
    }
    bt.inorder();
    return 0;
}
WQP_Ya_Ping
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树及其插入、删除操作
程序人生
10-19 2141
在二叉搜索树中，基本操作如结点的插入、删除、查找的性能上界都得不到保证，原因在于二叉搜索树的构造依赖于其结点值的插入顺序，最坏情况下二叉搜索树会退化为单链表（如下图所示）。因此我们需要对二叉搜索树做出一些改进和限制，从而使其拥有更好更稳定的性能上界保证。红黑树就是一种自平衡的二叉搜索树。 定义 红黑树除了满足二叉搜索树的性质以外，还有以下性质： （1）红黑树的结点都是带有“颜色”属性的，...
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告.docx
04-18
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告
C/C++数据结构（十二）—— 红黑树
Edison's 小宇宙
03-01 10万+
红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。
红黑树的插入和删除详解
xfy_von的博客
08-10 1530
红黑树RB-tree 找了很多其他人的，红黑树的插入大部分都能理解，在删除部分有些博客很难理解进行，就自己写了一篇详细的，有问题欢迎请指出。 作为一种广泛应用的平衡二叉搜索树之一，需要我们有些清晰的了解 红黑树的结点增删改查效率非常优良，都为log(N)，其应用十分广泛： Linux内核进程调度由红黑树管理进程控制块。 Epoll用红黑树管理事件块。 C++ STL中的map和set的底层实现。 用于理解红黑树的生成演示网站：https://www.cs.usfca.edu/~galles/visual
数据结构(61)：带你手撕红黑树的插入与删除（图文详解）
李白
01-05 2万+
红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。在二叉查找树的一般要求以外，对于任何有效的红黑树增加了如下的额外要求： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。） 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。 这些约束确保了红黑树的关键特性：从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如.
红黑树的经典介绍
坚持
04-21 975
目录 1 红黑树的介绍 2 红黑树的应用 3 红黑树的时间复杂度和相关证明 4 红黑树的基本操作(一) 左旋和右旋 5 红黑树的基本操作(二) 添加 6 红黑树的基本操作(三) 删除        作者：Sky Wang    于 2013-08-08                                概述：R-B Tree，又称为“红黑树”。本文参考
最容易懂得红黑树
热门推荐
Sun_TTTT的博客
03-23 13万+
介绍红黑树是一个平衡的二叉树，但不是一个完美的平衡二叉树。虽然我们希望一个所有查找都能在~lgN次比较内结束，但是这样在动态插入中保持树的完美平衡代价太高，所以，我们稍微放松逛一下限制，希望找到一个能在对数时间内完成查找的数据结构。这个时候，红黑树站了出来。 阅读以下需要了解普通二叉树的插入以及删除操作。 红黑树是在普通二叉树上，对没个节点添加一个颜色属性形成的，同时整个红黑二叉
红黑树插入删除的平衡操作
03-17
红黑树插入，删除时各种状态的平衡操作。
红黑树添加1111111
09-29
红黑树添加
红黑树添加删除节点操作详解资料整理.doc
01-09
stl源码剖析一书中关于红黑树删除的操作只字未提，删除操作比较复杂，没有相关说明比较晦涩。 本人再看这个函数时也是冒了一身冷汗，这方面的资料很匮乏，好容易找到了，与大家分享一下。。。
红黑树生成删除
07-04
红黑树在线生成的一个工具，从网上找的，我这样应该得不到分。大哭https://www.cnblogs.com/bbvi/p/5576201.html 删除可能存在问题，替换节点的兄弟节点为黑色节点时有问题，其他部分是没有问题的，凑合着看看
红黑树插入删除伪算法
03-10
该资源描述了红黑树插入删除的伪算法，并提供相关图示
红黑树的插入与删除_详细整理资料
02-25
红黑树的插入与删除_详细整理资料
红黑树插入删除算法
09-27
红黑树插入删除算法，算法导论上算法，可以运行
红黑树的添加删除操作
好好学习
07-09 2万+
<br /><br />来自: http://hi.baidu.com/coolinc/blog/item/3aa07f3e162502eb54e723b1.html<br />介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。<br />红黑树和之前所讲的
红黑树(red-black tree)算法，附AVL树的比较
jlu_zc的专栏
01-03 603
红黑树(red-black tree)算法，附AVL树的比较 【转】【经典】 导读：  　　linux内核中的用户态地址空间管理使用了红黑树(red-black tree)这种数据结构，我想一定有许多人在这种数据结构上感到困惑，我也曾经为此查阅了许多资料以便了解红黑树的原理。最近我在一个外国网站上看到一篇 讲解红黑树的文章，觉得相当不错，不敢独享，于是翻译
红黑树插入、删除、查找算法学习
雨纷飞
11-11 5107
红黑树(red-black tree)是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)，文章讲述红黑树的性质，结构描述，插入、删除算法分析，最后完成一个C语言测试程序。
网站界面设计mortal0418代码
04-18
网站界面设计mortal0418代码
PHP毕业设计-校园失物招领系统源码+数据库.zip
最新发布
04-18
PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可
写一个红黑树的删除操作
10-25
红黑树的删除操作相对于插入操作要复杂一些，因为删除节点后需要保证红黑树的性质仍然成立。下面是红黑树的删除操作步骤： 1. 找到要删除的节点，如果该节点有两个子节点，则找到该节点的后继节点（即右子树中最小...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值