红黑书（三）红黑树的删除操作

最新推荐文章于 2024-09-25 13:54:13 发布
最新推荐文章于 2024-09-25 13:54:13 发布
阅读量535 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 二叉树 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_jing_forever/article/details/45673721
版权

c++完整代码(带插入、删除、查找等)：


#include <iostream>
using namespace std;
#include <stack>

//颜色枚举;
enum _color
{
    _None,
    _Red,
    _Black
};
//结点结构;
struct tNode
{
    int iKey;
    int iColor;
    tNode* pParent;
    tNode* pLeft;
    tNode* pRight;

    tNode():
    iKey(NULL),
    iColor(_None),
    pParent(nullptr),
    pLeft(nullptr),
    pRight(nullptr)
    {

    }

};

class RBTree
{
public:
    RBTree():
    m_pRoot(nullptr),
    m_iCount(0)
    {
        m_pSentryNULL = new tNode();
        m_pSentryNULL->iColor = _Black;         //哨兵的颜色为黑色;
        m_pRoot = m_pSentryNULL;
    }
    ~RBTree()
    {
        delete m_pSentryNULL;
        m_pSentryNULL = nullptr;
    }
private:
    //根结点;
    tNode*          m_pRoot;
    //哨兵;
    tNode*          m_pSentryNULL;
    //元素数量;
    int             m_iCount;
private:
    //左旋;
    void left_Rotate(tNode* pNode)
    {
        if(pNode == nullptr||pNode == m_pSentryNULL||pNode->pRight == m_pSentryNULL)
        {
            return;
        }


        pNode->pRight->pParent = pNode->pParent;

        if (pNode->pParent == m_pSentryNULL)
        {
            m_pRoot = pNode->pRight;

        }
        else
        {
            if (pNode == pNode->pParent->pLeft)
            {
                pNode->pParent->pLeft = pNode->pRight;
            }
            else
            {
                pNode->pParent->pRight = pNode->pRight;
            }
        }
        pNode->pParent = pNode->pRight;

        if (pNode->pParent->pLeft == m_pSentryNULL)
        {
            pNode->pRight = m_pSentryNULL;
        }
        else
        {
            pNode->pRight->pLeft->pParent = pNode;
            pNode->pRight = pNode->pParent->pLeft;
        }

        pNode->pParent->pLeft = pNode;
    }
    //右旋;
    void right_Rotate(tNode* pNode)
    {
        if(pNode == nullptr||pNode == m_pSentryNULL||pNode->pLeft == m_pSentryNULL)
        {
            return;
        }

        pNode->pLeft->pParent = pNode->pParent;

        if (pNode->pParent == m_pSentryNULL)
        {
            m_pRoot = pNode->pLeft;

        }
        else
        {
            if (pNode == pNode->pParent->pLeft)
            {
                pNode->pParent->pLeft = pNode->pLeft;
            }
            else
            {
                pNode->pParent->pRight = pNode->pLeft;
            }
        }
        pNode->pParent = pNode->pLeft;
        if (pNode->pParent->pRight == m_pSentryNULL)
        {
            pNode->pLeft = m_pSentryNULL;
        }
        else
        {
            pNode->pLeft->pRight->pParent = pNode;
            pNode->pLeft = pNode->pParent->pRight;
        }
        pNode->pParent->pRight = pNode;

    }
    //插入调整;
    void RB_Insert_Fixup(tNode* pNode)
    {
        while (pNode->pParent->iColor == _Red)
        {
            if (pNode->pParent == pNode->pParent->pParent->pLeft)
            {
                tNode* pUncleNode = pNode->pParent->pParent->pRight;
                if (pUncleNode->iColor == _Red)//叔结点为红色;
                {
                    pUncleNode->iColor = _Black;
                    pNode->pParent->iColor = _Black;
                    pNode->pParent->pParent->iColor = _Red;
                    pNode = pNode->pParent->pParent;
                }
                else//叔结点为黑色;
                {
                    if (pNode == pNode->pParent->pRight)
                    {
                        pNode = pNode->pParent;
                        left_Rotate(pNode);
                    }
                    pNode->pParent->iColor = _Black;
                    pNode->pParent->pParent->iColor = _Red;
                    right_Rotate(pNode->pParent->pParent);

                }
            }
            else//对称操作
            {
                tNode* pUncleNode = pNode->pParent->pParent->pLeft;
                if (pUncleNode->iColor == _Red)//叔结点为红色;
                {
                    pUncleNode->iColor = _Black;
                    pNode->pParent->iColor = _Black;
                    pNode->pParent->pParent->iColor = _Red;
                    pNode = pNode->pParent->pParent;
                }
                else//叔结点为黑色;
                {
                    if (pNode == pNode->pParent->pLeft)
                    {
                        pNode = pNode->pParent;
                        right_Rotate(pNode);
                    }
                    pNode->pParent->iColor = _Black;
                    pNode->pParent->pParent->iColor = _Red;
                    left_Rotate(pNode->pParent->pParent);

                }
            }
        }

        m_pRoot->iColor = _Black;
    }

    //删除调整;
    void RB_Delete_Fixup(tNode* pNode)
    {
        while (pNode!=m_pRoot&&pNode->iColor == _Black)
        {
            if (pNode == pNode->pParent->pLeft)
            {
                tNode* pBrotherNode = pNode->pParent->pRight;   //兄弟结点;
                if (pBrotherNode->iColor == _Red)
                {
                    pNode->pParent->iColor = _Red;
                    pBrotherNode->iColor = _Black;
                    left_Rotate(pNode->pParent);
                    pBrotherNode = pBrotherNode->pParent->pRight;
                }

                if (pBrotherNode->iColor == _Black)
                {
                    if (pBrotherNode->pLeft->iColor == _Black&&pBrotherNode->pRight->iColor == _Black)
                    {
                        pBrotherNode->iColor = _Red;
                        pNode = pNode->pParent;
                    }
                    else
                    {
                        if(pBrotherNode->pRight->iColor == _Black)
                        {
                            pBrotherNode->iColor = _Red;
                            pBrotherNode->pLeft->iColor = _Black;
                            right_Rotate(pBrotherNode);
                            pBrotherNode = pNode->pParent->pRight;
                        }

                        pBrotherNode->iColor = pNode->pParent->iColor;
                        pNode->pParent->iColor = _Black;
                        pBrotherNode->pRight->iColor = _Black;
                        left_Rotate(pNode->pParent);
                        pNode = m_pRoot;
                    }

                }
            }
            else//对称操作;
            {

                tNode* pBrotherNode = pNode->pParent->pLeft;   //兄弟结点;
                if (pBrotherNode->iColor == _Red)
                {
                    pNode->pParent->iColor = _Red;
                    pBrotherNode->iColor = _Black;
                    right_Rotate(pNode->pParent);
                    pBrotherNode = pBrotherNode->pParent->pLeft;
                }

                if (pBrotherNode->iColor == _Black)
                {
                    if (pBrotherNode->pRight->iColor == _Black&&pBrotherNode->pLeft->iColor == _Black)
                    {
                        pBrotherNode->iColor = _Red;
                        pNode = pNode->pParent;
                    }
                    else
                    {
                        if(pBrotherNode->pLeft->iColor == _Black)
                        {
                            pBrotherNode->iColor = _Red;
                            pBrotherNode->pRight->iColor = _Black;
                            left_Rotate(pBrotherNode);
                            pBrotherNode = pNode->pParent->pLeft;
                        }

                        pBrotherNode->iColor = pNode->pParent->iColor;
                        pNode->pParent->iColor = _Black;
                        pBrotherNode->pLeft->iColor = _Black;
                        right_Rotate(pNode->pParent);
                        pNode = m_pRoot;
                    }

                }

            }
        }
        pNode->iColor = _Black;
    }
    //返回最小关键字元素;
    tNode* minNode(tNode* rootNode)
    {
        if(rootNode == m_pSentryNULL) return m_pSentryNULL;

        while (rootNode->pLeft!=m_pSentryNULL)
        {
            rootNode = rootNode->pLeft;
        }

        return rootNode;
    }
    //返回最大关键字元素;
    tNode* maxNode(tNode* rootNode)
    {
        if(rootNode == m_pSentryNULL) return m_pSentryNULL;

        while (rootNode->pRight!=m_pSentryNULL)
        {
            rootNode = rootNode->pRight;
        }

        return rootNode;
    }

    //替换子树;
    void transplantNode(tNode* pDesNode,tNode* pSrcNode)
    {
        if (pDesNode->pParent == m_pSentryNULL)
        {
            m_pRoot = pSrcNode;
        }
        else if(pDesNode == pDesNode->pParent->pLeft)
        {
            pDesNode->pParent->pLeft = pSrcNode;
        }
        else
        {
            pDesNode->pParent->pRight = pSrcNode;
        }

        pSrcNode->pParent = pDesNode->pParent;
    }
public:
    //查询数据;
    tNode* search(int iKey)
    {
        tNode* pTemp = m_pRoot;
        while(pTemp!=m_pSentryNULL&&iKey!=pTemp->iKey)
        {
            if (iKey<pTemp->iKey)
            {
                pTemp = pTemp->pLeft;
            }
            else
            {
                pTemp = pTemp->pRight;
            }
        }
        return pTemp;
    }

    //插入;
    void RB_Insert(tNode* pNode)
    {
        if(pNode == m_pSentryNULL)
        {
            return;
        }
        //二叉搜索树插入操作;
        tNode* pTemp = m_pRoot;
        tNode* pTempParent = m_pSentryNULL;
        while (pTemp!=m_pSentryNULL)
        {
            pTempParent = pTemp;
            if (pNode->iKey<pTemp->iKey)
            {
                pTemp = pTemp->pLeft;
            }
            else
            {
                pTemp = pTemp->pRight;
            }
        }

        pNode->pParent = pTempParent;

        if (m_pRoot == m_pSentryNULL)
        {
            m_pRoot = pNode;
        }
        else
        {
            if (pNode->iKey < pTempParent->iKey)
            {
                pTempParent->pLeft = pNode;
            }
            else
            {
                pTempParent->pRight = pNode;
            }
        }
        pNode->pLeft = m_pSentryNULL;
        pNode->pRight = m_pSentryNULL;
        pNode->iColor = _Red;
        m_iCount++;
        //调整以保持红黑性质;
        RB_Insert_Fixup(pNode);
    }
    //删除;
    void RB_Delete(tNode* pNode)
    {
        if (m_pRoot == m_pSentryNULL||pNode == m_pSentryNULL)
        {
            return;
        }

        int iDeleteColor = pNode->iColor;       //要删除的结点颜色;
        tNode* pSrcNode = nullptr;              //纪录替换删除位置的结点;

        if(pNode->pLeft == m_pSentryNULL)//左子结点不存在;
        {
            pSrcNode = pNode->pRight;
            transplantNode(pNode,pNode->pRight);
            cout<<"delete success!"<<endl;
        }
        else if(pNode->pRight == m_pSentryNULL)//左子结点存在,右子结点不存在;
        {
            pSrcNode = pNode->pLeft;
            transplantNode(pNode,pNode->pLeft);
            cout<<"delete success!"<<endl;
        }
        else//左右子结点都存在;
        {
            tNode* pSuccessor =minNode(pNode->pRight);//后继;
            iDeleteColor = pSuccessor->iColor;
            pSrcNode = pSuccessor->pRight;
            if (pSuccessor!=pNode->pRight)
            {
                transplantNode(pSuccessor, pSuccessor->pRight);
                pSuccessor->pRight = pNode->pRight;
                pSuccessor->pRight->pParent = pSuccessor;
            }
            transplantNode(pNode,pSuccessor);
            pSuccessor->pLeft = pNode->pLeft;
            pSuccessor->pLeft->pParent = pSuccessor;
            pSuccessor->iColor = pNode->iColor;
            cout<<"delete success!"<<endl;
        }

        m_iCount--;
        if (iDeleteColor == _Black)
        {
            RB_Delete_Fixup(pSrcNode);
        }
        delete pNode;
        pNode = nullptr;
    }
    //前驱;
    tNode* predecessorNode(tNode* pNode)
    {
        if (pNode->pLeft!=m_pSentryNULL)
        {
            return maxNode(pNode->pLeft);
        }
        tNode* pTemp = pNode->pParent;

        while (pTemp!=m_pSentryNULL&&pTemp->pLeft == pNode)
        {
            pNode = pTemp;
            pTemp = pTemp->pParent;
        }
        return pTemp;
    }
    //后继;
    tNode* successorNode(tNode* pNode)
    {
        if (pNode->pRight!=m_pSentryNULL)
        {
            return minNode(pNode->pRight);
        }
        tNode* pTemp = pNode->pParent;

        while (pTemp!=m_pSentryNULL&&pTemp->pRight == pNode)
        {
            pNode = pTemp;
            pTemp = pTemp->pParent;
        }
        return pTemp;
    }

    //获得最小的元素值;
    const int& getMinValue()
    {
        tNode* pTemp = minNode(m_pRoot);
        if (pTemp!=m_pSentryNULL)
        {
            return pTemp->iKey;
        }
        else
        {
            return NULL;
        }
    }
    //获得最大的元素值;
    const int& getMaxValue()
    {
        tNode* pTemp = maxNode(m_pRoot);
        if (pTemp!=m_pSentryNULL)
        {
            return pTemp->iKey;
        }
        else
        {
            return NULL;
        }
    }


    //判断红黑树是否为空;
    bool empty()
    {
        if (m_iCount == 0)
        {
            return true;
        }
        return false;
    }
    //插入元素;
    void push(int iData)
    {
        tNode* pNode = new tNode;
        if (pNode)
        {
            pNode->iKey = iData;
            RB_Insert(pNode);
        }
    }
    //获得元素数目;
    const int& size()
    {
        return m_iCount;
    }
    //遍历;
    void traversal()
    {
        //中序遍历;
        if (m_pRoot == m_pSentryNULL)
        {
            return;
        }

        stack<tNode*> _stack;
        tNode* pTemp = m_pRoot;
        while (m_pSentryNULL!=pTemp||!_stack.empty())
        {
            if (m_pSentryNULL!=pTemp)
            {
                _stack.push(pTemp);
                pTemp = pTemp->pLeft;
            }
            else
            {
                pTemp = _stack.top();
                cout<<pTemp->iKey<<"    "<<pTemp->iColor<<endl;
                _stack.pop();
                pTemp = pTemp->pRight;
            }
        }
    }


};


//测试代码;
RBTree _rbTree;

cout<<"empty "<<_rbTree.empty()<<endl;

_rbTree.push(11);
_rbTree.push(7);
_rbTree.push(5);
_rbTree.push(12);
_rbTree.push(6);
cout<<"empty "<<_rbTree.empty()<<endl;

//cout<<"size  "<<_rbTree.size()<<endl;
//_rbTree.traversal();

_rbTree.RB_Delete(_rbTree.search(7));
cout<<"size  "<<_rbTree.size()<<endl;
_rbTree.traversal();
//测试代码输出;
empty 1
empty 0
delete success!
size  4
5    2
6    1
11    2
12    2
念念不忘_lovejing
关注
专栏目录
红黑树 - Robert Sedgewick 2008
08-27
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出，因其独特的颜色属性和插入、删除操作而被广泛应用在数据结构和算法领域。"红黑树 - Robert Sedgewick 2008"是Robert Sedgewick教授于2008年在普林斯顿...
红黑树系列三：红黑树的删除
lpp0900320123的专栏
10-11 1748
一、红黑树定义  红黑树需要满足下面4个条件：      1、每个节点不是红色就是黑色。      2、根节点为黑色。      3、如果节点为红色，其子节点必须为黑色。      4、任意一个节点到到NULL（树尾端）的任何路径，所含之黑色节点数必须相同。 二、红黑树的删除 对二叉查找树，我们知道删除的结点可能有三种情况：(1)为叶子结点，(2)左子树或右子树有
他一口气写出了这7k字的红黑树总结！看过的都说好！！|文末送书
HollisChuang's Blog
12-23 838
△Hollis, 一个对Coding有着独特追求的人△这是Hollis的第244篇原创分享作者 l shanhm1991来源 l Hollis（ID：hollisch...
一个高效的定时器分析及设计
快乐无处不在
11-01 542
对于一个游戏而言，定时器是必须的，而它一般作为一个游戏基本公共组件，而定时器在游戏逻辑中运用是非常明显的(比如吃药回血，每几秒回血多少)，而对于游戏逻辑而言需要开发一个高效率高精度(毫秒级别)的定时器。 　　一：分析Ace库定时器实现方式 　　1.Ace种定时器实现有4种，这里不具体介绍实现细节，主要介绍实现数据结构，性能。 　　具体的4种定时器都是从ACE_Timer_Queue_T继承，
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
红黑树的基本性质（共四篇）
lm2009200的博客
04-10 7757
1.什么是红黑树 我们知道一棵高度为h的二叉搜索树的大部分操作时间复杂度是O(h)，但是如果搜索树较高，极端情况下就是一条链表了，二叉搜索的意义就不大了。而红黑树是一颗二叉搜索树，也是多种平衡搜索树的一种，可以保证最坏情况下时间复杂度为O(lgn)。对于一棵有n个内部节点的红黑树的高度最多为2lg(n+1)，高度的证明不难，请参考算法导论。 2.红黑树的五大性质 这五
红黑树代码
05-07
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它的设计目标是尽可能地减少在数据操作，特别是插入和删除时导致的不平衡。这种数据结构在计算机科学中被广泛应用于各种需要高效查找、插入和删除操作的场景，如...
红黑树的C++实现
01-24
- 《算法导论》第三版详细介绍了红黑树的理论基础和操作细节。书中通过一系列的案例分析和证明，解释了如何保持红黑树的平衡以及为什么这些操作能保证O(log n)的时间复杂度。 红黑树是数据结构和算法领域中的一个...
C++红黑书源码
09-10
红黑书实现代码,添加删除操作以及红黑书调整操作
算法导论的红黑树的C++实现源码
03-29
基于这些特性，红黑树保证了任何节点到其每个叶子节点的所有路径都具有相同的黑色节点数量，从而保证了树的高度被控制在log₂(n)+1，n为节点数量，这使得红黑树在插入、删除和查找操作上的平均时间复杂度为O(log n)...
一篇文章彻底搞懂红黑树(多图,看完包懂)
vjhghjghj的博客
03-24 5007
Table of Contents 1.定义 2.性质 3.基本操作 4.功能 4.1查找 4.2 插入 4.3 删除 5.红黑树的部分实现 6.应用--map/multimap 0.概述 2.用法 7.应用--set/multiset 1.概述 2.用法 8.问题&总结 0.概述 如上图整理所示 红黑树是一种平衡的二叉树,引入它为了解决的...
红黑树的删除—10张图学会
早就戒了的博客
12-23 1万+
如果要学红黑树，那么就必须知道二叉树，毕竟红黑树本身就是一个二叉搜索树。只不过红黑树比一般的二叉搜索树更加稳定，也就是更加平衡，但是有没有AVL树那么的稳定，这换来的是红黑树比AVL数有更好的插入和删除效率，但是查找效率并没有比AVL差很多。下文我将用RBT代替红黑树。二叉搜索树的删除介绍RBT的删除，就先要知道二叉搜索树的删除(知道的同学可以直接跳过)。删除分为四步： 1.找到删除点假设为X
红黑树删除操作的各种情况分析
马小超
12-07 1443
目录 删除情况具体分析 1. 删除的节点没有子节点的情况 2. 删除的节点只有一个子节点时 3. 如果删除节点有两个子节点时 红黑树删除平衡情况分析 红黑书的删除本质上是一个穷举的过程。 删除情况具体分析 1. 删除的节点没有子节点的情况  a、如果为红色，直接删除即可，不会影响黑色节点的数量   删除红色节点（13）示例（不影响黑色节点数量，不需要平衡操作）  b、如果为黑色，删除的时候需要进行平衡操作   删除示例，删除节点11（平衡操作后面会介绍到） 2. 删除的节点只有一个子..
【树】 红黑树（通俗易懂）
读书与思考的乐趣
09-16 1686
教你透彻了解红黑树 二叉查找树 由于红黑树本质上就是一棵二叉查找树，所以在了解红黑树之前，咱们先来看下二叉查找树。 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 370
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 504
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
【优选算法】（第一篇）
最新发布
weixin_73861555的博客
09-25 1056
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
红黑树算法详解：性质、旋转、插入、删除操作
红黑树的基本操作包括插入、删除和查找。 插入操作： 1. 如果树为空，则创建一个新的红色节点作为根节点。 2. 如果树不为空，则找到插入点，分为两种情况： a. 如果插入点的父节点是红色的，那么旋转操作将其变为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值