红黑树基本操作实现

最新推荐文章于 2024-07-23 15:43:10 发布
最新推荐文章于 2024-07-23 15:43:10 发布
阅读量627 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanshui/article/details/71172058
版权

红黑树的插入，删除简单实现

主要理解的难点在删除的实现，当删除节点存在左右子节点时，需选择右侧后续节点，然后替换两个节点，当被替换节点是叶节点时，需要重新平衡该树，此时以空节点染黑代替进行平衡操作，再做各种变换，与书上的图操作相似， 详见“[balance]”

#ifndef CRBTREE_H
#define CRBTREE_H

#include <cstddef>
using namespace std;

enum NodeColor{
    colorred,
    colorblack
};

template <class T>
struct RBNode
{
    NodeColor color;
    RBNode *leftnode;
    RBNode *rightnode;
    RBNode *parentnode;
    T obj;
};

template <class T>
RBNode<T> *__InitNode(const T& obj)
{
    RBNode<T> *rbnode = new RBNode<T>();
    rbnode->color = colorred;
    rbnode->leftnode = NULL;
    rbnode->rightnode = NULL;
    rbnode->parentnode = NULL;
    rbnode->obj = obj;
    return rbnode;
}

template <class T>
class CRBTree
{
public:
    typedef RBNode<T> NodeType;
    typedef NodeType* NodeTypePtr;
    typedef T value_type;

    CRBTree(){
        headnode = NULL;
    }
    ~CRBTree(){
    }
    bool Empty() { return headnode == NULL; }
    void Insert(const value_type &obj)
    {
        NodeType *newnode = __InitNode(obj);
        if (Empty())
        {
            newnode->color = colorblack;
            headnode = newnode;
        }
        else
        {
            _InsertNode(newnode);
            if (newnode->parentnode->color == colorred)
            {
                _Recolor(newnode);
            }
        }
    }
    void Erase(const value_type &obj)
    {
        NodeType *_EraseNode = _FindNode(headnode, obj);
        if (_EraseNode)
        {
            NodeTypePtr _Fixnode;	// the node to recolor as needed
            NodeTypePtr _Fixnodeparent;	// parent of _Fixnode (which may be nil)
            NodeTypePtr _Pnode = _EraseNode;

            if (_Pnode->leftnode == NULL)
                _Fixnode = _Pnode->rightnode;	// stitch up right subtree
            else if (_Pnode->rightnode == NULL)
                _Fixnode = _Pnode->leftnode;	// stitch up left subtree
            else
            {	// two subtrees, must lift successor node to replace erased
                _Pnode = (++iter(_EraseNode)).data();	// _Pnode is successor node
                _Fixnode = _Pnode->rightnode;	// _Fixnode is only subtree
            }
            if (_Pnode == _EraseNode)
            {   // at most one subtree, relink it,only black parent link one red child
                _Fixnodeparent = _EraseNode->parentnode;
                if (_Fixnode != NULL)
                    _Fixnode->parentnode = _Fixnodeparent;
                if (headnode == _EraseNode)
                    headnode = _Fixnode;
                else if (_Fixnodeparent->leftnode == _EraseNode)
                    _Fixnodeparent->leftnode = _Fixnode;
                else
                    _Fixnodeparent->rightnode = _Fixnode;
            }
            else
            {  //two subtrees, find the successor node and swap with the Erasenode
                _EraseNode->leftnode->parentnode = _Pnode;
                _Pnode->leftnode = _EraseNode->leftnode;
                if (_EraseNode->rightnode == _Pnode)
                {
                    _Fixnodeparent = _Pnode;
                }
                else
                {
                    _Fixnodeparent = _Pnode->parentnode;
                    if (_Fixnode != NULL)
                        _Fixnode->parentnode = _Fixnodeparent;
                    _Fixnodeparent->leftnode = _Fixnode;
                    _Pnode->rightnode = _EraseNode->rightnode;
                    _EraseNode->rightnode->parentnode = _Pnode;
                }
                if (headnode == _EraseNode)
                    headnode = _Pnode;
                else if (_EraseNode->parentnode->leftnode == _EraseNode)
                    _EraseNode->parentnode->leftnode = _Pnode;
                else
                    _EraseNode->parentnode->rightnode = _Pnode;
                _Pnode->parentnode = _EraseNode->parentnode;
                //swap color
                NodeColor color = _Pnode->color;
                _Pnode->color = _EraseNode->color;
                _EraseNode->color = color;
            }
            if (_EraseNode->color == colorblack)
            {
                if (_Fixnode != NULL)
                    _Fixnode->color = colorblack;
                else
                {   //[balance]
                    while (_Fixnode != headnode && (_Fixnode == NULL || _Fixnode->color == colorblack))
                    {
                        if (_Fixnode == _Fixnodeparent->leftnode)
                        {
                            NodeTypePtr _Unclenode = _Fixnodeparent->rightnode;
                            if (_Unclenode->color == colorred)
                            {
                                _Unclenode->color = colorblack;
                                _Fixnodeparent->color = colorred;
                                _LeftRotate(_Fixnodeparent);
                                _Unclenode = _Fixnodeparent->rightnode;
                            }
                            if ((_Unclenode->leftnode == NULL || _Unclenode->leftnode->color == colorblack) &&
                                    (_Unclenode->rightnode == NULL || _Unclenode->rightnode->color == colorblack))
                            {
                                _Unclenode->color = colorred;
                                _Fixnode = _Fixnodeparent;
                                _Fixnodeparent = _Fixnodeparent->parentnode;
                            }
                            else
                            {
                                if (_Unclenode->rightnode == 0 || _Unclenode->rightnode->color == colorblack)
                                {
                                    if (_Unclenode->leftnode != NULL)
                                        _Unclenode->leftnode->color = colorblack;
                                    _Unclenode->color = colorred;
                                    _RightRotate(_Unclenode);
                                    _Unclenode = _Fixnodeparent->rightnode;
                                }
                                _Unclenode->color = _Fixnodeparent->color;
                                _Fixnodeparent->color = colorblack;
                                if (_Unclenode->rightnode != NULL) _Unclenode->rightnode->color = colorblack;
                                _LeftRotate(_Fixnodeparent);
                                break;
                            }
                        }
                        else
                        {
                            NodeTypePtr _UncleNode = _Fixnodeparent->leftnode;
                            if (_UncleNode->color == colorred)
                            {
                                _UncleNode->color = colorblack;
                                _Fixnodeparent->color = colorred;
                                _RightRotate(_Fixnodeparent);
                                _UncleNode = _Fixnodeparent->leftnode;
                            }
                            if ((_UncleNode->rightnode == NULL ||_UncleNode->rightnode->color == colorblack) &&
                                (_UncleNode->leftnode == NULL || _UncleNode->leftnode->color == colorblack))
                            {
                                _UncleNode->color = colorred;
                                _Fixnode = _Fixnodeparent;
                                _Fixnodeparent = _Fixnodeparent->parentnode;
                            }
                            else
                            {
                                if (_UncleNode->leftnode == NULL || _UncleNode->leftnode->color == colorblack)
                                {
                                    if (_UncleNode->rightnode)
                                        _UncleNode->rightnode->color = colorblack;
                                    _UncleNode->color = colorred;
                                    _LeftRotate(_UncleNode);
                                    _UncleNode = _Fixnodeparent->leftnode;
                                }
                                _UncleNode->color = _Fixnodeparent->color;
                                _Fixnodeparent->color = colorblack;
                                if (_UncleNode->leftnode) _UncleNode->leftnode->color = colorblack;
                                _RightRotate(_Fixnodeparent);
                                break;
                            }
                        }
                    }
                    if (_Fixnode) _Fixnode->color = colorblack;
                }
            }
            delete _EraseNode;
        }
    }
    class iter{
    public:
        iter(NodeType *node)
            :_node(node)
        {

        }
        iter operator ++()
        {
            if (_node->rightnode)
            {
                _node = _node->rightnode;
                while(_node && _node->leftnode)
                {
                    _node = _node->leftnode;
                }
            }
            else if (_node->parentnode == NULL)
            {
                _node = NULL;
            }
            else if (_node == _node->parentnode->leftnode)
            {
                _node = _node->parentnode;
            }
            else if (_node == _node->parentnode->rightnode)
            {
                NodeType *_parent = _node->parentnode;
                if (_parent->parentnode && _parent == _parent->parentnode->leftnode)
                {
                    _node = _parent->parentnode;
                }
                else
                {
                    _node = NULL;
                }
            }
            return *this;
        }
        bool operator == (const iter& other)
        {
            return _node == other._node;
        }
        bool operator != (const iter& other)
        {
            return _node != other._node;
        }
        NodeType* operator -> () const { return _node;}
        NodeType* data() const { return _node; }
    private:
        NodeType *_node;
    };
    iter begin()
    {
        NodeType *_tnode = headnode;
        if (_tnode != NULL)
        {
            while(_tnode->leftnode)
            {
                _tnode = _tnode->leftnode;
            }
        }
        return iter(_tnode);
    }
    iter end()
    {
        return iter(NULL);
    }
    void clear()
    {
        _Erase(headnode);
        headnode = NULL;
    }
private:
    NodeType *headnode;
    void _LeftRotate(NodeType *nodeA){
        NodeType *nodeB = nodeA->rightnode;
        NodeType *nodeC = nodeB->leftnode;
        nodeA->rightnode = nodeC;
        if (nodeC) nodeC->parentnode = nodeA;
        nodeB->leftnode = nodeA;
        nodeB->parentnode = nodeA->parentnode;
        if (nodeA->parentnode == NULL)
            headnode = nodeB;
        else
        {
            if (nodeA->parentnode->leftnode == nodeA)
                nodeA->parentnode->leftnode = nodeB;
            else
                nodeA->parentnode->rightnode = nodeB;
        }
        nodeA->parentnode = nodeB;
    }
    void _RightRotate(NodeType *nodeA){
        NodeType *nodeB = nodeA->leftnode;
        NodeType *nodeC = nodeB->rightnode;
        nodeA->leftnode = nodeC;
        if (nodeC) nodeC->parentnode = nodeA;
        nodeB->rightnode = nodeA;
        nodeB->parentnode = nodeA->parentnode;
        if (nodeA->parentnode == NULL)
            headnode = nodeB;
        else
        {
            if (nodeA->parentnode->leftnode == nodeA)
                nodeA->parentnode->leftnode = nodeB;
            else
                nodeA->parentnode->rightnode = nodeB;
        }
        nodeA->parentnode = nodeB;
    }
    void _InsertNode(NodeType *node)
    {
        NodeType *parent = headnode;
        do{
            if (node->obj < parent->obj)
            {
                if (parent->leftnode == NULL)
                {
                    parent->leftnode = node;
                    node->parentnode = parent;
                    break;
                }
                else
                    parent = parent->leftnode;
            }
            else
            {
                if (parent->rightnode == NULL)
                {
                    parent->rightnode = node;
                    node->parentnode = parent;
                    break;
                }
                else
                    parent = parent->rightnode;
            }
        }while(1);
    }

    NodeType* _FindNode(NodeType *pNode,const value_type& obj)
    {
        NodeType *_node = pNode;
        do{
            if (_node == NULL || _node->obj == obj)
            {
                return _node;
            }
            else if (_node->obj < obj)
            {
                return _FindNode(_node->rightnode, obj);
            }
            else
            {
                return _FindNode(_node->leftnode, obj);
            }
        }while(1);
    }

    void _Recolor(NodeType *node)
    {
        NodeType *_parent = node->parentnode;
        if (node == headnode)
        {
            node->color = colorblack;
        }
        else if (_parent->color == colorblack)
        {
            return;
        }
        else
        {
            NodeType *_grand = _parent->parentnode;
            if (_parent == _grand->leftnode)
            {
                NodeType *_uncle = _grand->rightnode;
                if (_uncle && _uncle->color == colorred)
                {
                    _parent->color = colorblack;
                    _uncle->color = colorblack;
                    _grand->color = colorred;
                    _Recolor(_grand);
                }
                else
                {
                    if (node == _parent->rightnode)
                    {
                        node = node->parentnode;
                        _LeftRotate(node);
                    }
                    node->parentnode->color = colorblack;
                    node->parentnode->parentnode->color = colorred;
                    _RightRotate(node->parentnode->parentnode);
                }
            }
            else
            {
                NodeType *_uncle = _grand->leftnode;
                if (_uncle && _uncle->color == colorred)
                {
                    _parent->color = colorblack;
                    _uncle->color = colorblack;
                    _grand->color = colorred;
                    _Recolor(_grand);
                }
                else
                {
                    if (node == _parent->leftnode)
                    {
                        node = node->parentnode;
                        _RightRotate(node);
                    }
                    node->parentnode->color = colorblack;
                    node->parentnode->parentnode->color = colorred;
                    _LeftRotate(node->parentnode->parentnode);
                }
            }
        }
    }

    void _Erase(NodeType *node)
    {
        for (NodeType *_Pnode = node; _Pnode != NULL; node = _Pnode)
        {	// free subtrees, then node
            _Erase(_Pnode->rightnode);
            _Pnode = _Pnode->leftnode;
            delete node;
        }
    }
};



#endif // CRBTREE_H

测试代码：

#include <iostream>
#include "rbtree.h"
using namespace std;

void printtree(CRBTree<int>& rbtree)
{
    //check tree balance
    int blackdepth = 0;
    for ( CRBTree<int>::iter it = rbtree.begin(); it != rbtree.end(); ++it)
    {
        int branchdepth = 0;
        if (it->leftnode == NULL || it->rightnode == NULL)
        {
            branchdepth ++;
            RBNode<int>* node = it.data();
            while (node != NULL)
            {
                if (node->color == colorblack)
                    branchdepth++;
                node = node->parentnode;
            }
            if (blackdepth == 0)
                blackdepth = branchdepth;
            else if (blackdepth != branchdepth)
                cout << "RBTree is not balance now!\n";
        }

    }
    for ( CRBTree<int>::iter it = rbtree.begin(); it != rbtree.end(); ++it)
    {
        cout << it->obj;
        const char *temp = (it->color==colorblack) ? "B" : "R";
        cout << temp;
        if (it->leftnode != NULL)
            cout << 'l';
        if (it->rightnode != NULL)
            cout << 'r';
        if (it->parentnode == NULL)
            cout << 'H';
        cout << "  ";
    }
    cout << endl;
}

int main()
{
    CRBTree<int> rbtree;
    for (int i=0; i<61; i++)
    {
        rbtree.Insert(i);
        printtree(rbtree);
    }
	int arrint[] = {1, 7, 5, 20, 4, 6, 9, 10, 17, 3, 2, 15, 60, 55};
    for (unsigned int i=sizeof(arrint)/sizeof(arrint[0]); i>0; i--)
    {
        rbtree.Erase(arrint[i-1]);
        printtree(rbtree);
    }
	rbtree.clear();
    return 0;
}



sanshui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树基本操作算法
10-12
红黑树插入删除算法，检查了几次都没有错误，算法导论
C++简单实现红黑树的插入
06-06
红黑树插入操作的基本步骤如下： 1. **基础插入**：首先，将新插入的节点标记为红色，因为插入红色节点不会违反红黑树的任何性质。然后，将新节点作为当前根节点的左或右子节点，如果根节点为空，则新节点成为新的...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 19万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3458
红黑树详解、模拟实现
C语言 红黑树分析与实现
C++ 开发者的博客
12-11 1043
重要概念 红黑树的资料网上资料很多，对红黑树的定义、性质、以及操作都做了详细的分析，这篇博文也参考了网上的很多文章，不过主要是学习了腾讯课堂-零声king老师的课之后，对红黑树的一些理解。肯定有一些错误的地方，如果觉得不对，可以给我指出。 参考资料 如果你对红黑树的基本概念，用途，性质等不了解，那么请先看红黑树(一)之 原理和算法详细介绍的文章，里面对红黑树的了解很仔细，这篇博客主要是用C语言来实现红黑树。 红黑树性质 （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL
红黑树C语言代码实现
北街lhy的博客
07-23 1018
通过对红黑树的左旋、右旋、变色操作，以及前驱节点和后继节点的查找，我们能够维护红黑树的平衡性，确保其高效的查找、插入和删除操作。本文详细介绍了这些辅助操作的实现代码，为深入理解红黑树提供了基础。红黑树通过在插入和删除节点后进行必要的旋转和变色操作，确保树的高度始终保持平衡，从而保证高效的查找、插入和删除操作。本文详细讲解了红黑树的插入操作及其调整机制，通过具体代码展示了实现过程。理解红黑树的这些基本操作对于掌握高级数据结构和算法具有重要意义。红黑树的删除操作比插入操作复杂得多，需要考虑多种情况。
红黑树C#实现
d65793577的专栏
08-13 925
一、红黑树的性质 红黑树是一种特殊的二叉搜索树 每个节点只有红色或者黑色。 根节点一定是黑色。 叶子节点一定是空节点，且是黑色。 每个红色节点一定有两个黑色节点，即不能有连续的红色节点。 从一个节点到他的所有叶子节点，所经历的黑色节点数目相同。 二、红黑树的优点 红黑树的结构复杂，但它的操作有着良好的最坏情况运行时间，并且在实践中高效：它可以在O(logn)O(log_n)O(logn​)时间内完成查找、插入和删除，这里的nnn是树中元素的数目。 三、实现红黑树 3.1 基本结构 3.1.1 节点
C++实现红黑树
hdsHDS6的博客
06-28 1597
C++实现红黑树，插入和删除思路
图解红黑树
Dablelv 的博客专栏。
08-10 1708
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
java代码实现红黑树源码
weixin_40037053的博客
05-08 1万+
红黑树是一种近似平衡的二叉查找树，它能够确保任何一个节点的左右子树的高度差不会超过二者中较低那个的一陪。具体来说，红黑树是满足如下条件的二叉查找树（binary search tree）： 每个节点要么是红色，要么是黑色。 根节点必须是黑色 红色节点不能连续（也即是，红色节点的孩子和父亲都不能是红色）。 对于每个节点，从该点至null（树尾端）的任何路径，都含有相同个数的黑色节点。 在树的结构发...
红黑树原理解析以及Java实现
qq_32534441的博客
03-07 2467
转自：https://blog.csdn.net/u010853261/article/details/54312932 红黑树 本文的主要内容： 1、红黑树的基本概念以及最重要的5点规则。 2、红黑树的左旋转、右旋转、重新着色的原理与Java实现； 3、红黑树的增加结点、删除结点过程解析； 1.红黑树的基本概念与数据结构表示 首先红黑树来个定义： 红黑树定义：红黑树又称红-黑二叉树，...
红黑树简单实现
07-06
在本项目中，我们将探讨如何实现一个简单的红黑树，包括普通树的构建、查询功能以及红黑树的特殊性质和操作。 首先，我们需要理解二叉树的基本概念。二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常分为...
红黑树的实现
06-17
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。...理解并正确实现红黑树的插入和删除操作对于提升数据结构和算法能力至关重要。在编程中，需要特别注意边界条件和错误处理，以确保红黑树的正确性。
C++红黑树实现过程
09-15
总之，红黑树是数据结构和算法领域的一个重要课题，其C++实现涉及对数据结构的理解、指针操作、以及复杂的逻辑判断。通过分析`rbtree.c`和`rbtree.h`文件，我们可以学习如何在实际项目中应用这一高效的数据结构。
数理方法习题 前六章.pdf
08-03
数理方法习题 前六章
某大型制造企业IT蓝图规划及实施路线.pptx
08-03
某大型制造企业IT蓝图规划及实施路线.pptx
基于Springboot和Vue的社区团购系统设计源码 社区团购系统设计代码（98分期末优秀大作业）
08-03
社区团购系统设计源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
去哪儿旅游&小红书-旅行行业：2023五一旅行趋势报告—想出去玩.pdf
最新发布
08-03
去哪儿旅游&小红书-旅行行业：2023五一旅行趋势报告—想出去玩
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值