数据结构之红黑树（C++实现）

已于 2023-01-13 20:38:58 修改
阅读量378 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
于 2023-01-13 20:37:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHAKMING1/article/details/128679297
版权

数据结构之红黑树

我之前的博客已经介绍过了二叉树和AVL树的基本概念和简单实现，具体参考数据结构-树（C语言实现篇）和数据结构之AVL树（C++实现）。

1. 红黑树

1.1 红黑树的概念

红黑树也是一种二叉搜索树，在此基础上每个结点增加一个存储位表示结点的颜色，可以是红色或者黑色，通过对任何一条从根节点到叶子结点的路径上每个结点颜色的限制，红黑树确保没有一条路径会比其他路径大一倍，因此，是接近平衡的一颗二叉搜索树。

在这里插入图片描述

1.2 红黑树的性质
  1. 每个结点的颜色不是红色就是黑色。
  2. 根节点是黑色的。
  3. 如果一个节点是红色的，那么它的两个孩子结点是黑色的。
  4. 对于每个结点，从该结点到其所有后代的叶子结点的路径上，均包含相同数目的黑色结点。
  5. 每个叶子结点都是黑色的**（指的是空节点）**。

2. 红黑树的实现

2.1 红黑树结点的定义
// 结点的颜色
enum Colour {
    RED,
    BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;     // 左孩子
	RBTreeNode<K, V>* _right;   // 右孩子
	RBTreeNode<K, V>* _parent; // 父节点

	pair<K, V> _kv;  // 存储对
	Colour _col;      // 存储颜色

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
	{}
};
2.2 红黑树的插入操作

红黑树是在二叉搜索树的基础上加上了平衡限制条件，故分为两步：

  1. 按照二叉搜索树的规则插入新节点。

    typedef RBTreeNode<K, V> Node;
bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        _root->_col = BLACK; // 根节点必须为黑色
        return true;
    }
	
    // 按照二叉排序树的思路进行查找
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }

    cur = new Node(kv);
    if (parent->_kv.first < kv.first)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = cur;
    }

    cur->_parent = parent;
}

  2. 检测新结点插入之后，红黑树的性质是否被破坏。

    因为新插入的结点默认是红色的，因此，如果双亲结点是黑色，则没有违反红黑树任何性质。如果插入结点的双亲结点是红色的，就违背了红色结点的两个孩子结点是黑色的的性质。针对不同的情况进行分析：

    • 情况一：cur为红色，parent为红色，grandfather为黑色，uncle为红色。

在这里插入图片描述

 设置双亲结点和双亲的兄弟结点为黑色。
 如果g结点为根节点，那么设置为黑色。因为根节点必须是黑色。
 如果g结点不为根节点，那么设置为红色，然后继续向上调整。
  • 情况二：cur为红色，parent为红色，grandfather为黑色，uncle不存在/存在且为黑色。

在这里插入图片描述
说明：（u结点分两种情况）

 如果u结点不存在，则cur一定是新插入的结点，因为cur和p都为红色，故冲突发生在这里，一定是有一个结点不满足，才会导致性质失效。
 如果u结点存在，则其一定是黑色的，那么cur结点原来的颜色也是黑色的，因为如果cur原来不是黑色的，就不满足从根节点到叶子结点的黑色节点数量相同。现在看到是黑色的原因在于cur的子树在调整过程中将cur结点的颜色从黑色改为红色。
 p结点为g结点的左孩子，cur结点为p结点的左孩子，进行右单旋。
 p结点为g结点的右孩子，cur结点为p结点的右孩子，进行左单旋。
 p结点变成黑色，g结点变成红色。
  • 情况三：cur为红色，parent为红色，grandfather为黑色，uncle不存在/存在且为黑色。
    在这里插入图片描述
p结点为g结点的左孩子，cur结点为p的右孩子，则对p做左单旋。
p结点为g结点的右孩子，cur结点为p的左孩子，则对p做右单旋。
最终变成了情况二，按照情况二接着处理即可。

  1. 代码实现：

    // parent为红色
while (parent && parent->_col == RED)
{
    Node* grandfater = parent->_parent;
    assert(grandfater);
    assert(grandfater->_col == BLACK); // 如果爷爷的颜色不为黑色，那么前面的操作有误
    // 关键看叔叔
    // 若p为g左子树
    if (parent == grandfater->_left)
    {
        Node* uncle = grandfater->_right;
        // 情况一 : uncle存在且为红，变色+继续往上处理
        // 情况一只用变色，不需要旋转
        if (uncle && uncle->_col == RED)
        {
            parent->_col = uncle->_col = BLACK;
            grandfater->_col = RED;
            // 继续往上处理
            cur = grandfater;
            parent = cur->_parent;
        }// 情况二+三：uncle不存在 + 存在且为黑
        else
        {
            // 情况二：右单旋+变色
            //     g 
            //   p   u
            // c
            if (cur == parent->_left)
            {
                RotateR(grandfater); // 采用AVL树的旋转策略
                parent->_col = BLACK;
                grandfater->_col = RED;
            }
            else
            {
                // 情况三：左右单旋+变色
                //     g 
                //   p   u
                //     c
                RotateL(parent);  // 这一步结束后变成了情况二
                RotateR(grandfater); 
                cur->_col = BLACK;
                grandfater->_col = RED;
            }
			// 不需要在往上调整
            break;
        }
    }
    else // (parent == grandfater->_right)
    {
        Node* uncle = grandfater->_left;
        // 情况一
        if (uncle && uncle->_col == RED)
        {
            parent->_col = uncle->_col = BLACK;
            grandfater->_col = RED;
            // 继续往上处理
            cur = grandfater;
            parent = cur->_parent;
        }
        else
        {
            // 情况二：左单旋+变色
            //     g 
            //   u   p
            //         c
            if (cur == parent->_right)
            {
                RotateL(grandfater);
                parent->_col = BLACK;
                grandfater->_col = RED;
            }
            else
            {
                // 情况三：右左单旋+变色
                //     g 
                //   u   p
                //     c
                RotateR(parent);
                RotateL(grandfater);
                cur->_col = BLACK;
                grandfater->_col = RED;
            }
            break;
        }
    }
}

// 记得最后需要将根节点设置为黑色
_root->_col = BLACK;
2.3 红黑树的验证

红黑树的验证分为两步：

  1. 检测其是否满足二叉搜索树（中序序列是否是有序序列）。

    void InOrder()
{
    _InOrder(_root);
    cout << endl;
}

void _InOrder(Node* root)
{
    if (root == nullptr)
    {
    	return;
    }

    _InOrder(root->_left);
    cout << root->_kv.first << ":" << root->_kv.second << endl;
    _InOrder(root->_right);
}

  2. 检测是否满足红黑树的性质。

    bool IsBalance() 
{
    /* 性质：
        1. 根节点是黑色的
        2. 如果一个节点是红色的，则它的两个孩子结点是黑色的
        3. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
        4. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
     */
    if (_root == nullptr)
        return true;
    if (_root->_col == RED) {
        cout << "根节点不是黑色" << endl;
        return false;
    }
    // 黑色节点数量基准值
    int benchmark = 0;
    return PrevCheck(_root, 0, benchmark);
}

/*
	思路：
	判断每条路径上的黑色节点个数是否相同。
	blackNum为当前路径结点的个数
	benchmark第一次为0，第二次为第一次获取路径结点的个数
	如果benchmark不等于blackNum，表示当前路径的黑色节点个数与其他路径不相同，则不满足红黑树的条件。
*/
bool PrevCheck(Node *root, int blackNum, int &benchmark) 
{
    if (root == nullptr) {
        if (benchmark == 0) {
            benchmark = blackNum;
            return true;
        }

        if (blackNum != benchmark) {
            cout << "黑色节点数量不相等" << endl;
            return false;
        } else {
            return true;
        }
    }
    // 如果为黑色，那么黑色节点数量++
    if (root->_col == BLACK)
        ++blackNum;
	
    // 检查当前结点与其双亲结点是否都为红色
    if (root->_col == RED && root->_parent->_col == RED) {
        cout << "出现连续的红色结点" << endl;
        return false;
    }
    return PrevCheck(root->_left, blackNum, benchmark)
        && PrevCheck(root->_right, blackNum, benchmark);
}
2.4 红黑树的删除

红黑树的删除这里不做讨论，有兴趣可以参考：《算法导论》或者《STL源码剖析》

https://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html

2.5 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log_2(n))，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

CHAK&MING
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
(数据结构)C++实现红黑树
Juheng_luo的博客
03-30 1057
(数据结构)C++实现红黑树
C++ 数据结构 红黑树 图文详解
weixin_44062380的博客
06-21 891
红黑树前言为什么要红黑树？红黑树需要遵守的性质红黑树的变换方式红黑树的变换原则代码展示红黑树和AVL树该怎么选择 前言 我不喜欢搞什么“一文看懂XXX”的标题，因为如果一开始看到“一文读懂XXX”的标题，然后放松警惕，但当读完后，发现自己没有懂，难免会感到失落与担忧。大多数时候，这不是读者的问题，而是写作者的问题，写作者并没有将内容写得通俗易懂，却起这种标题去吸引眼球，从而使部分读者产生心理落差，这是极不负责的表现。 因为马上就要算法考试了，所以代码没时间写了，一部分概念也没时间细说了，这次就先把变色和旋转
红黑树的详细实现(C++)
code_peak
10-08 6017
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
C++简单实现红黑树
weixin_50601177的博客
09-28 274
C++实现红黑树
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3420
红黑树详解、模拟实现
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2251
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，...熟练掌握红黑树的原理和C++实现，对于提升数据结构和算法能力以及解决实际编程问题都具有重要意义。
C++数据结构 红黑树 实现全部功能
12-29
总结来说，红黑树是一种重要的数据结构，它的核心在于通过特定的平衡策略保持了二叉查找树的高效性。在C++中实现红黑树需要理解其基本概念，设计合适的类结构，并正确实现各种操作，包括插入、删除和查找，以及相关...
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
红黑树C++实现
01-27
红黑树的C++完整实现代码
rbtrees:红黑树的旧 C++ 实现
07-14
树 红黑树的旧 C++ 实现 线程安全红黑树的 C++ 实现，不使用 STL，完全没有外部依赖。 该实现是通用且高效的。 插入 100 万个 int32_t 键节点需要 521 毫秒，而从 100 万个节点树中检索需要 2 毫秒！！ 编译，签出并运行make 。 注意您必须安装 gtest 才能运行测试套件
红黑树_ C++模板实现
11-08
详细的红黑树C++模板实现，调试后运行正确。 template class RBTree { private: static node *nil;//哨兵，静态成员，被整个RBTree类所共有 node *root; RBTree(const RBTree&);//禁止复制构造 RBTree operator=(const RBTree&);//禁止赋值 void leftRotate(node*);//左旋 void rightRotate(node*);//右旋 void insertFixup(node*);//插入节点后红黑性质调整 void eraseFixup(node*);//删除节点后红黑性质调整 public: RBTree():root(nil) { root->parent = nil; root->left = nil; root->right = nil; root->color = black; } RBTree(node *rbt):root(rbt){}//复制构造函数，用于创建子红黑树对象 void insert(const T&);//插入 void create();//创建红黑树 void erase(const T&);//删除 node* locate(const T&)const;//查找 node* minMum()const;//最小值 node* maxMum()const;//最大值 node* successor(const T&)const;//找后继 node* predecessor(const T&)const;//前驱 void preTraversal()const;//先根遍历 void inTraversal()const;//中根遍历 void destroy();//销毁红黑树 bool empty()const{return root == nil;}//判空 };
红黑树的c实现源码与教程
10-01
cpp 文档，可以直接编译运行 部分内容如下 int main() { int i,count=900000; key_t key; rb_node_t *root=NULL,*node=NULL; srand(time(NULL)); for(i=1;i<count;++i){ key=rand()%count; if((root=rb_insert(key,i,root))){ printf("[i=%d] insert key %d success!\n",i,key); } else{ printf("[i=%d] insert key %d error!\n",i,key); exit(-1); } if((node=rb_search(key,root))){ printf("[i=%d] search key %d success!\n",i,key); } else{ printf("[i=%d] search key %d error!\n",i,key); exit(-1); } if(!(i)){ if((root=rb_erase(key,root))){ printf("[i=%d] erase key %d success!\n",i,key); } else{ printf("[i=%d] erase key %d error！\n",i,key); } } } return 0; } 由JULY所写，我只是将pdf转为txt而已
C++红黑树实现过程
09-15
用C++实现的红黑树，没有BUG ，稍微改改就能直接运行了，最优的代码了，拿去研究吧，也没什么可以说的了···
C++简单实现红黑树的插入
最新发布
06-06
红黑树是一种自平衡二叉查找树，它在数据结构中扮演着重要的角色，尤其在高效算法实现中。它的设计目标是确保查找、插入和删除等操作的时间复杂度都接近于O(log n)。在C++中实现红黑树，我们需要理解其特性并将其...
【C++】红黑树的实现
m0_65679465的博客
05-16 607
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。map 、set 两个关联式容器的底层就是红黑树。
详解c++---红黑二叉树的原理和实现
qq_68695298的博客
06-17 1789
红黑二叉树的原理以及模拟实现
C++map的数据结构红黑树
07-09
在C++中，std::map 是使用红黑树（RedBlack Tree）作为底层数据结构实现的。红黑树是一种自平衡二叉查找树，它具有以下特点： 1. 每个节点要么红色，要么是黑色。 2. 根节点是黑色的。 3. 所有叶子节点（NIL节点）都是黑色的。 4. 如果一个节点是红色的，则它的两个子节点都是黑色的。 5. 对于每个节点，从该节点到其后代叶子节点的简单路径上，均包含相同数目的黑色节点。 这些特性保证了红黑树的平衡性，使得在最坏情况下，插入、删除和查找操作的时间复杂度都是O(log n)。 std::map 是C++标准库中提供的关联容器之一，它提供了一种键值对的存储方式，并根据键的顺序自动进行排序。通过使用红黑树作为底层数据结构，std::map 可以在插入、删除和查找操作上具有较好的性能表现。 以下是一个使用 std::map 的简单示例： ```cpp #include <iostream> #include <map> int main() { std::map<int, std::string> myMap; // 插入键值对 myMap.insert(std::make_pair(1, "Apple")); myMap.insert(std::make_pair(2, "Banana")); myMap.insert(std::make_pair(3, "Orange")); // 遍历输出 for (const auto& pair : myMap) { std::cout << pair.first << ": " << pair.second << std::endl; } // 查找键对应的值 auto it = myMap.find(2); if (it != myMap.end()) { std::cout << "Value of key 2: " << it->second << std::endl; } return 0; } ``` 上述示例中，我们使用 std::map 存储了一些水果的名称，并按照键的顺序输出。通过调用 find() 函数，我们可以查找指定键对应的值。 希望以上回答能够解决你的问题！如有更多疑问，请继续提问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值