【C++学习】红黑树

于 2024-05-20 10:17:01 发布
阅读量845 收藏 28
点赞数 22
分类专栏： C++ 文章标签： 学习 c++ 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44906102/article/details/138802299
版权

目录

一、红黑树的概念

二、红黑树的性质      

三、红黑树节点的定义

四、红黑树的结构

五、红黑树的插入操作

5.1 按照二叉搜索的树规则插入新节点

5.2 检测新节点插入后，红黑树的性质是否造到破坏  

5.2.1 情况一：cur为红，p为红，g为黑，u存在且为红

5.2.2 情况二：cur为红，p为红，g为黑，u不存在/u存在且为黑

六、红黑树的验证

七、红黑树模拟实现STL中的map与set

7.1 红黑树的迭代器

7.2 改造红黑树

7.3 map的模拟实现

7.4 set的模拟实现

一、红黑树的概念

        红黑树，是一种 二叉搜索树 ，但 在每个结点上增加一个存储位表示结点的颜色，可以是 Red或B lack 。 通过对 任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径 会比其他路径长出俩倍 ，因而是 接近平衡 的。

二、红黑树的性质      

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的 
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

三、红黑树节点的定义

// 节点的颜色
enum Color{RED, BLACK};

// 红黑树节点的定义
template<class ValueType>
struct RBTreeNode
{
    RBTreeNode(const ValueType& data = ValueType()，Color color = RED)
        : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
        , _data(data), _color(color)
    {}

    RBTreeNode<ValueType>* _pLeft;   // 节点的左孩子
    RBTreeNode<ValueType>* _pRight;  // 节点的右孩子
    RBTreeNode<ValueType>* _pParent; // 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)
    ValueType _data;            // 节点的值域
    Color _color;               // 节点的颜色
};

四、红黑树的结构

        为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点， pLeft域指向红黑树中最小的节点，_pRight 域指向红黑树中最大的节点，如下：

五、红黑树的插入操作

        红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

5.1 按照二叉搜索的树规则插入新节点

template<class ValueType>
class RBTree
{
    //……
    bool Insert(const ValueType& data)
    {
        PNode& pRoot = GetRoot();
        if (nullptr == pRoot)
        {
            pRoot = new Node(data, BLACK);

            // 根的双亲为头节点
            pRoot->_pParent = _pHead;
            _pHead->_pParent = pRoot;
        }
        else
        {
             // 1. 按照二叉搜索的树方式插入新节点
             // 2. 检测新节点插入后，红黑树的性质是否造到破坏，
             //   若满足直接退出，否则对红黑树进行旋转着色处理
        }

        // 根节点的颜色可能被修改，将其改回黑色
        pRoot->_color = BLACK;
        _pHead->_pLeft = LeftMost();
        _pHead->_pRight = RightMost();
        return true;
    }

private:
    PNode& GetRoot(){ return _pHead->_pParent; }

    // 获取红黑树中最小节点，即最左侧节点
    PNode LeftMost();

    // 获取红黑树中最大节点，即最右侧节点
    PNode RightMost();

private:
    PNode _pHead;
};

5.2 检测新节点插入后，红黑树的性质是否造到破坏  

        因为新节点的默认颜色是红色 ，因此：如果 其双亲节点的颜色是黑色，没有违反红黑树任何 性质 ，则不需要调整；但 当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连 在一起的红色节点 ，此时需要对红黑树分情况来讨论：

        约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

5.2.1 情况一：cur为红，p为红，g为黑，u存在且为红

cur和 p 均为红，违反了性质三，此处能否将 p 直接改为黑？
解决方式：将p,u 改为黑， g 改为红，然后把 g 当成 cur ，继续向上调整。
5.2.2 情况二：cur为红，p为红，g为黑，u不存在/u存在且为黑

p 为 g 的左孩子， cur 为 p 的左孩子，则进行右单旋转；相反，
p 为 g 的右孩子， cur 为 p 的右孩子，则进行左单旋转
p 、 g 变色 --p 变黑， g 变红

5.2.3 情况三：cur为红，p为红，g为黑，u不存在/u存在且为黑

p 为 g 的左孩子， cur 为 p 的右孩子，则针对 p 做左单旋转；相反，
p 为 g 的右孩子， cur 为 p 的左孩子，则针对 p 做右单旋转
则转换成了情况 2

针对每种情况进行相应的处理即可。 
bool Insert(const ValueType& data)
{
    // ...
    // 新节点插入后，如果其双亲节点的颜色为空色，则违反性质3：不能有连在一起的红色结点
    while(pParent && RED == pParent->_color)
    {
        // 注意：grandFather一定存在
        // 因为pParent存在，且不是黑色节点，则pParent一定不是根，则其一定有双亲
        PNode grandFather = pParent->_pParent;

        // 先讨论左侧情况
        if(pParent == grandFather->_pLeft)
        {
            PNode unclue = grandFather->_pRight;

            // 情况三：叔叔节点存在，且为红
            if(unclue && RED == unclue->_color)
            {
                pParent->_color = BLACK;
                unclue->_color = BLACK;
                grandFather->_color = RED;
                pCur = grandFather;
                pParent = pCur->_pParent;
            }
            else
            {
                // 情况五：叔叔节点不存在，或者叔叔节点存在且为黑
                if(pCur == pParent->_pRight)
                {
                    _RotateLeft(pParent);
                    swap(pParent, pCur);
                }

                // 情况五最后转化成情况四
                grandFather->_color = RED;
                pParent->_color = BLACK;
                _RotateRight(grandFather);
            }
        }
        else
        {
            // 右侧……
        }
    }
    // ...
}  

六、红黑树的验证

红黑树的检测分为两步：
  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质 
bool IsValidRBTree()
{
    PNode pRoot = GetRoot();
    // 空树也是红黑树
    if (nullptr == pRoot)
        return true;

    // 检测根节点是否满足情况
    if (BLACK != pRoot->_color)
    {
        cout << "违反红黑树性质二：根节点必须为黑色" << endl;
        return false;
    }

    // 获取任意一条路径中黑色节点的个数
    size_t blackCount = 0;
    PNode pCur = pRoot;

    while (pCur)
    {
        if (BLACK == pCur->_color)
            blackCount++;
        pCur = pCur->_pLeft;
    }

    // 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
    size_t k = 0;
    return _IsValidRBTree(pRoot, k, blackCount);
}

bool _IsValidRBTree(PNode pRoot, size_t k, const size_t blackCount)
{
    //走到null之后，判断k和black是否相等
    if (nullptr == pRoot)
    {
        if (k != blackCount)
        {
            cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
            return false;
        }
        return true;
    }

    // 统计黑色节点的个数
    if (BLACK == pRoot->_color)
        k++;

    // 检测当前节点与其双亲是否都为红色
    PNode pParent = pRoot->_pParent;
    if (pParent && RED == pParent->_color && RED == pRoot->_color)
    {
        cout << "违反性质三：没有连在一起的红色节点" << endl;
        return false;
    }

    return _IsValidRBTree(pRoot->_pLeft, k, blackCount) &&
        _IsValidRBTree(pRoot->_pRight, k, blackCount);
}

七、红黑树模拟实现STL中的map与set

7.1 红黑树的迭代器

        迭代器的好处是可以方便遍历，是数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以前问题：
  • begin() 与 end()
    STL 明确规定， begin() 与 end() 代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin() 可以放在红黑树中最小节点 ( 即最左侧节点 ) 的位 置 ， end() 放在最大节点 ( 最右侧节点 ) 的下一个位置 ，关键是最大节点的下一个位置在哪块？ 能否给成nullptr 呢？答案是行不通的，因为 对 end() 位置的迭代器进行 -- 操作，必须要能找最 后一个元素 ，此处就不行，因此最好的方式是 将 end() 放在头结点的位置。
  • operator++() 与 operator--() 
// 找迭代器的下一个节点，下一个节点肯定比其大
void Increasement()
{
    //分两种情况讨论:_pNode的右子树存在和不存在
    // 右子树存在
    if(_pNode->_pRight)
    {
        // 右子树中最小的节点，即右子树中最左侧节点
        _pNode = _pNode->_pRight;
        while(_pNode->_pLeft)
            _pNode = _pNode->_pLeft;
    }
    else
    {
        // 右子树不存在，向上查找，直到_pNode != pParent->right
        PNode pParent = _pNode->_pParent;
        while(pParent->_pRight == _pNode)
        {
            _pNode = pParent;
            pParent = _pNode->_pParent;
        }

        // 特殊情况：根节点没有右子树
        if(_pNode->_pRight != pParent)
            _pNode = pParent;
    }
}
// 获取迭代器指向节点的前一个节点
void Decreasement()
{
     //分三种情况讨论：_pNode 在head的位置，_pNode 左子树存在，_pNode 左子树不存在

     // 1. _pNode 在head的位置，--应该将_pNode放在红黑树中最大节点的位置
    if(_pNode->_pParent->_pParent == _pNode && _pNode->_color == RED)
        _pNode = _pNode->_pRight;

    else if(_pNode->_pLeft)
    {
        // 2. _pNode的左子树存在,在左子树中找最大的节点，即左子树中最右侧节点
        _pNode = _pNode->_pLeft;
        while(_pNode->_pRight)
            _pNode = _pNode->_pRight;
    }
    else
    {
        // _pNode的左子树不存在，只能向上找
        PNode pParent = _pNode->_pParent;
        while(_pNode == pParent->_pLeft)
        {
            _pNode = pParent;
            pParent = _pNode->_pParent;
        }
        _pNode = pParent;
    }
}

7.2 改造红黑树

// 因为关联式容器中存储的是<key, value>的键值对，因此
// k为key的类型，
// ValueType: 如果是map，则为pair<K, V>; 如果是set，则为k
// KeyOfValue: 通过value来获取key的一个仿函数类

template<class K, class ValueType, class KeyOfValue>
class RBTree
{
    typedef RBTreeNode<ValueType> Node;
    typedef Node* PNode;
public:
    typedef RBTreeIterator<ValueType, ValueType*, ValueType&> Iterator;
public:
    RBTree();
        ~RBTree()

    // Iterator
    Iterator Begin(){ return Iterator(_pHead->_pLeft);}
    Iterator End(){ return Iterator(_pHead);}


    // Modify
    pair<Iterator, bool> Insert(const ValueType& data)
    {
        // 插入节点并进行调整
        // 参考上文...
        return make_pair(Iterator(pNewNode), true);
    }

    // 将红黑树中的节点清空
    void Clear();
    Iterator Find(const K& key);


    // capacity
    size_t Size()const;
    bool Empty()const;
    // ……

private:
    PNode _pHead;
    size_t _size;  // 红黑树中有效节点的个数
};

7.3 map的模拟实现

        map的底层结构就是红黑树，因此在 map 中直接封装一棵红黑树，然后将其接口包装下即可 
namespace bite
{
    template<class K, class V>
    class map
    {
        typedef pair<K, V> ValueType;

        // 作用：将value中的key提取出来
        struct KeyOfValue
        {
            const K& operator()(const ValueType& v)
            { return v.first;}
        };

        typedef RBTree<K, ValueType, KeyOfValue> RBTree;

    public:
        typedef typename RBTree::Iterator iterator;
    public:
        map(){}

   /

        // Iterator
        iterator begin(){ return _t.Begin();}
        iterator end(){ return _t.End();}

    /

        // Capacity
        size_t size()const{ return _t.Size();}
        bool empty()const{ return _t.Empty();}

 /
 
        // Acess
        V& operator[](const K& key)
        { return (*(_t.Insert(ValueType(key, V()))).first).second;}

        const V& operator[](const K& key)const;

 

        // modify
        pair<iterator, bool> insert(const ValueType& data) 
        { return _t.Insert(data);}

        void clear(){ _t.Clear();}
        iterator find(const K& key){ return _t.Find(key);}
    private:
        RBTree _t;
    };
}

7.4 set的模拟实现

        set的底层为红黑树，因此只需在 set 内部封装一棵红黑树，即可将该容器实现出来 ( 具体实现可参考map) 
namespace bit
{
    template<class K>
    class set
    {
        typedef K ValueType;

        // 作用是：将value中的key提取出来
        struct KeyOfValue
        {
            const K& operator()(const ValueType& key)
            { return key;}
        };
        // 红黑树类型重命名
        typedef RBTree<K, ValueType, KeyOfValue> RBTree;
    public:
        typedef typename RBTree::Iterator iterator;
    public:
        Set(){}
 
/

        // Iterator
        iterator Begin();
        iterator End();

 /

        // Capacity
        size_t size()const;
        bool empty()const;

 

        // modify
        pair<iterator, bool> insert(const ValueType& data)
        {
            return _t.Insert(data);
        }
        void clear();
        iterator find(const K& key);
    private:
        RBTree _t;
    };
}
Cassooo_
关注
  • 22
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 基于红黑树的map和set
qq_54178958的博客
10-18 567
/ 节点的颜色// 红黑树节点的定义{{}// 节点的左孩子// 节点的右孩子// 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)// 节点的值域// 节点的颜色};
STL之set和multiset详解
Keep Moving~
05-15 6947
本文主要介绍了set/multiset内部数据实现原理，set的两种排序准则定义方式，同时也给出了set特殊成员搜寻函数，最后给出三种示例代码介绍set的应用。
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2313
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
＜map与set的模拟实现＞——《C++高阶》
m0_57859086的博客
08-14 709
——《》C++高阶
【C++】—— 实现底层为红黑树的Map和Set
chenxiyuehh的博客
04-27 2941
STL关联式容器map/set介绍： https://blog.csdn.net/chenxiyuehh/article/details/89361160 红黑树的模拟实现 https://blog.csdn.net/chenxiyuehh/article/details/89437298 这两篇博客介绍了map/set的相关接口使用和红黑树的模拟实现，现在我们来用一个红黑树封装实现MyMap和M...
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
红黑树-使用C++实现-简单练习
12-05
在学习c++的过程中实现的红黑树,功能比较完善,无优化..
红黑树的例子
08-10
红黑树的一个小例子，可以学习下挺好的，赞一个！
红黑树及AVL树常见平衡树实现
01-16
实现了红黑树、AVL树的基本功能增删改查。学习交流，共同进步
数据结构课程设计：基于Qt实现的个人通讯录系统及红黑树的实现.zip
10-30
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。...
红黑树与set, map
UnknownPlayer的博客
11-23 496
1. set和map的底层结构: 红黑树(rb_tree) 需要注意的是, 红黑树的结构是允许我们用iterator改变元素值的, 但是不应该这么做, 因为红黑树会自动排序, 如果我们改变值, 就会破坏红黑树的结构. 后面会看到, set和map把这种自由度给限制了. 下面是GNU2.9的rb_tree代码, 可以看到, 模板需要传入key, value, keyofvalue, compare...
AVL树和红黑树（map和set的底层实现）
海盗船长y的博客
04-26 1222
map和set的概念及使用 map和set的底层结构 map和set其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉...
【C++】红黑树（Red Black Tree）
knous
08-04 434
红黑树的一些操作
C++模拟实现红黑树，封装map和set
小白的Coding之旅
03-24 505
红黑树 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包...
简单实现map和set
xd6905的博客
05-17 273
一、红黑树 1 红黑树迭代器 难点是Increament和DeIncreament函数，用来实现迭代器的加加减减。下面讲解一下Increament的思路，DeIncreament思路与其大致思路相同，不过就是一个相反的关系。 红黑树按照中序遍历，当前节点加加就应该要到当前节点的右子树找最左节点，但是右节点有可能为null。因此就需要分右节点是否为空两种情况。 当右节点不为空，到右子树找最左节点。当右节点为空，说明以该节点为根的子树已经遍历完了，向上找父...
C++实现红黑树
hdsHDS6的博客
06-28 1522
C++实现红黑树，插入和删除思路
【C++】红黑树的完整实现
ly_6699的博客
05-04 451
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdlib.h> #pragma once #include <iostream> using namespace std; enum color { RED, BLACK }; template<class K, class V> struct RBSTreeN...
【C++】红黑树 --- map/set 底层
最新发布
YoungMLet的博客
11-13 1162
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
图解集合7：红黑树概念、红黑树的插入及旋转操作详细解读
love252223849的博客
07-15 762
原文地址：http://www.cnblogs.com/xrq730/p/6867924.html初识TreeMap之前的文章讲解了两种Map，分别是HashMap与LinkedHashMap，它们保证了以O(1)的时间复杂度进行增、删、改、查，从存储角度考虑，这两种数据结构是非常优秀的。另外，LinkedHashMap还额外地保证了Map的遍历顺序可以与put顺序一致，解决了HashMap本身无序
平衡树和红黑树的书籍
07-27
有几本关于平衡树和红黑树的书籍可以推荐给你： 1. 《算法导论》（Introduction to Algorithms）- Thomas H. Cormen 等人 这本经典教材详细介绍了平衡树和红黑树的原理、性质和实现，并提供了相应的伪代码和示例。 2. 《数据结构与算法分析》（Data Structures and Algorithm Analysis in C++）- Mark Allen Weiss 该书深入讲解了平衡树和红黑树的概念、应用和实现方法，并提供了C++代码示例。 3. 《算法（第4版）》（Algorithms, Part I）- Robert Sedgewick, Kevin Wayne 这本书由知名算法专家撰写，其中包含了对平衡树和红黑树的讲解，配有Java代码示例。 4. 《数据结构与算法分析：C语言描述》（Data Structures and Algorithm Analysis in C）- Clifford A. Shaffer 该书以C语言为基础，详细介绍了平衡树和红黑树的实现原理和应用，适合C语言开发者阅读。 以上是一些被广泛推荐的书籍，它们对于理解平衡树和红黑树的概念和实现方法非常有帮助。你可以根据自己的编程语言和阅读习惯选择适合的一本进行深入学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cassooo_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值