[数据结构 - C++] 红黑树RBTree

2024-01-22 18:44
文章标签 c++ 数据结构 红黑树 rbtree

本文主要是介绍[数据结构 - C++] 红黑树RBTree，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在这里插入图片描述

文章目录

  • 1、前言
  • 2、红黑树的概念
  • 3、红黑树的性质
  • 4、红黑树节点的定义
  • 5、红黑树的插入Insert
  • 6、红黑树的验证
  • 7、红黑树与AVL树的比较
  • 附录：

1、前言

我们在学习了二叉搜索树后，在它的基础上又学习了AVL树，知道了AVL树是靠平衡因子来调节左右高度差，从而让树变得平衡的。本篇我们再来学习一个依靠另一种平衡规则来控制的二叉搜索树——红黑树。

2、红黑树的概念

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

3、红黑树的性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（红色不能连续，黑色可以连续）
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
概念中，说到没有一条路径会比其他路径长出俩倍，性质3与性质4相互牵制就可以保证这一点。

4、红黑树节点的定义

我们定义节点依然是三叉链，与AVL树不同的是红黑树没有平衡因子，而是保存一个代表节点颜色的属性。

enum Color
{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;Color _col;RBTreeNode(const pair<K, V>& _kv):_left(nullptr),_right(nullptr),_parent(nullptr),_kv(kv),_col(RED){}
};

这里我们定义的红黑树节点，颜色默认给的红色，但是这里是给红色还是黑色合适呢？
当插入的时候，我们新插入的节点颜色是黑色时，就会破坏性质3，新插入节点的这条路径的黑色节点数一定会比其他路径的黑色节点多一个，影响整棵树。
如果是红色，那插入的时候她的父节点可能是黑色，没有影响，可能是红色，那么就会出现连续的红色节点，但是它只会影响这一条路径。
这两种颜色插入，黑色是一定会影响，红色是可能会影响的，且黑色影响整棵树，红色影响它这一条路径，两害取其轻，我们选择红色，调整的话也比较容易调整。下面我们就来尝试看插入怎么写：

5、红黑树的插入Insert

红黑树的插入是在二叉搜索树插入基础上来修改的，因此大的方向分两步走：
1、找到插入的位置；
2、插入节点后，根据性质来调节平衡。

bool Insert(const pair<K, V>& kv)
{if (nullptr == _root){_root = new Node(data);_root->_col = BLACK; // 性质2：根节点是黑色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;}}// 新增插入节点是红色只会影响父节点，如果是黑色影响所有路径// 所以 new 的节点为红色cur = new Node(kv);cur->_col = RED;if (parent->_kv.first < kv.first){parent->_right = cur;cur->_parent = parent;}else{parent->_left = cur;cur->_parent = parent;}// 维护处理 ...
}

当来到这块时，已经插入了，要做的就是按照性质来检查和维护这棵树了。
1、当父亲是黑色，那么就不用维护，就结束了；
2、当父亲是红色，那么就违反了性质3（不能存在连续的红色节点），这时就需要调整了，调整也是要分情况讨论（约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点）。
情况一：cur是红色，p为红色，g为黑色，u存在且为红色
这里看到的这棵树可能是完整的，也可能是子树：
在这里插入图片描述

如果是完整的树，那么改完之后，需要将g的颜色改为黑色。
如果g是子树，那么g就有父节点，这时g的颜色改为红色，父节点颜色可能也是红色，这时急需要继续向上调整了。
将p，u改为黑，g改为红，然后把g当作cur，继续向上调整。
情况二：cur是红色，p为红色，g为黑色，u不存在/u存在且为黑色
在这里插入图片描述

这里u有两种颜色，我们分开讨论：

  • 如果u不存在，那么cur一定是新增。因为u不存在g也是有一条右边路径的，这条路径就两个黑色节点（空结点也是黑色），那么c就不存在，a、b都不存在，如果存在就是黑色节点，那么就打破了性质3。
  • 如果存在且为黑，那么这个抽象图就不全。因为父节是红色，叔叔为黑色，每条路径的黑色节点个数要相同，因此推测出cur之前应该是黑色，那么a、b就应该是红色，新增节点在a/b的孩子位置。
    整体就为下图：
    在这里插入图片描述

它会先经过情况一的调整方式，调整完变为情况二这样，然后再继续调整：
在这里插入图片描述

此时，就 以g为基点先右旋，然后将父节点颜色变为黑色，祖父节点颜色变为红色。（旋转不清楚的同学可以看看AVL树的）
情况三：cur是红色，p为红色，g为黑色，u不存在/u存在且为黑色
在这里插入图片描述

  • u不存在，cur是新增。因为每条路径的黑色节点个数相同，u不存在，u这条路径上两个黑色节点（空结点也是黑色），推测出a、b、c都是不存在的，那么cur就是新增，如果存在只能是黑色节点，那么就打破了性质3。
  • 如果存在且为黑，这个抽象图依然是不完整的。因为父节点是红色，叔叔为黑色，每条路径的黑色节点相同，因此推测出a为黑色，cur之前也应该为黑色，那么b、c就应该是红色，新增节点在b/c的孩子位置。

图跟情况二中，u存在且为黑差不多：
在这里插入图片描述

会先经过情况一调整，变为情况三这样，然后进行调整：
在这里插入图片描述

此时，先以p为基点左旋，再以g为基点右旋，然后将cur节点变为黑色，祖父节点变为红色。
如果新增的父节点在右，叔叔节点在左，那么也是分以上三种情况，调整方式也是对应三种方式差不多，这里就不过多赘述，直接上代码：

bool Insert(const pair<K, V>& kv)
{if (nullptr == _root){_root = new Node(data);_root->_col = BLACK; // 性质2：根节点是黑色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;}}// 新增插入节点是红色只会影响父节点，如果是黑色影响所有路径// 所以 new 的节点为红色cur = new Node(kv);cur->_col = RED;if (parent->_kv.first < kv.first){parent->_right = cur;cur->_parent = parent;}else{parent->_left = cur;cur->_parent = parent;}// 不断向上调整的，所以得用whilewhile (parent && parent->_col == RED){// 父节点是祖父节点的左//      g//    p   u//  c Node* grandfather = parent->_parent;// 1、父节点在祖父的左，即叔叔在右if (parent == grandfather->_left){Node* uncle = grandfather->_right;// 1.1 叔叔存在并且为红if (uncle && uncle->_col == RED){// 变色parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 向上调整cur = grandfather;parent = cur->_parent;}// 1.2 叔叔不存在 / 叔叔存在且为黑，处理方法一样else{if (cur == parent->_left) // 左边高的情况{// 右单旋//     g//   p   u// cRotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else // 左边高右边高的情况{// 双旋//     g//  p     u//    cRotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}// 此时不用祖父位置为黑色不用在网上调整了break;}}// 2、父节点在祖父的右，即叔叔在祖父的左else // parent == grandfather->_right{//     g//   u   p//         cNode* uncle = grandfather->_left;// 2.1 叔叔存在且叔叔为红色if (uncle && uncle->_col == RED){// 变色parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 向上调整cur = grandfather;parent = cur->_parent;}// 2.2 叔叔不存在 / 叔叔存在且颜色为黑，处理方法一样else{if (cur == parent->_right) // 右边高的情况{//     g//   u   p//         cRotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else // 右边高，左边高{//     g//  u     p//      cRotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}// 此时不用祖父位置为黑色不用在网上调整了break;}}}// 最后将根节点变为黑色_root->_col = BLACK;return true;
}// 左单旋
void RotateL(Node* parent)
{Node* subR = parent->_right;Node* subRL = subR->_left;Node* parentParent = parent->_parent;parent->_right = subRL;if (subRL)subRL->_parent = parent;subR->_left = parent;parent->_parent = subR;if (_root == parent) // 父节点就是根节点{_root = subR;subR->_parent = nullptr;}else // 子树情况{if (parentParent->_left == parent){parentParent->_left = subR;}else{parentParent->_right = subR;}subR->_parent = parentParent;}
}// 右单旋
void RotateR(Node* parent)
{Node* parentParent = parent->_parent;Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR)subLR->_parent = parent;subL->_right = parent;parent->_parent = subL;if (_root == parent) // 父节点是根节点{_root = subL;subL->_parent = nullptr;}else // 子树情况{if (parentParent->_left == parent){parentParent->_left = subL;}else{parentParent->_right = subL;}subL->_parent = parentParent;}
}

6、红黑树的验证

红色树的验证本质就是验证两方面：
1、是否为二叉搜索树（中序遍历是否有序）；
2、是否满足5条性质。

void _InOrder(Node* pRoot)
{if (pRoot == nullptr)return;_InOrder(pRoot->_left);cout << pRoot->_data << " ";_InOrder(pRoot->_right);
}bool IsBalance()
{if (_root == nullptr) return true;if (_root->_col == RED) return false;// 参考值int refValue = 0;Node* cur = _root;while (cur){if (cur->_col == BLACK) refValue++;cur = cur->_left;}// 检查每条路径黑色节点个数// 思路：以上面参考值为主，对比每条路径的黑色节点个数// 当走到空就说明该路径走完了，那么这个过程中记录下黑色节点个数，到空时与refValue对比// 这里传进去blacknum只能是传值，这样就不会影响上一层的blacknum了int blacknum = 0;// 检查连续红色节点与每条路径黑色节点个数return Check(_root, blacknum, refValue);
}
bool Check(Node* root, int blacknum, const int& refValue)
{if (root == nullptr){if (blacknum != refValue){cout << "存在黑色节点不相等的路径" << endl;return false;}return true;}// 反向检查，查看当前与父结点为红色(当前节点为红色就说明不是根节点，即存在父节点)if (root->_col == RED && root->_parent->_col == RED){cout << "有连续的红色节点" << endl;return false;}if (root->_col == BLACK) blacknum++;return Check(root->_left, blacknum, refValue)&& Check(root->_right, blacknum, refValue);
}

7、红黑树与AVL树的比较

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

附录：

enum Color
{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;Color _col;RBTreeNode(const pair<K, V>& _kv):_left(nullptr),_right(nullptr),_parent(nullptr),_kv(kv),_col(RED){}
};template <class K, class V>
class RBTree
{typedef RBTreeNode<K,V> Node;
public:bool Insert(const pair<K, V>& kv){if (nullptr == _root){_root = new Node(data);_root->_col = BLACK; // 性质2：根节点是黑色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;}}// 新增插入节点是红色只会影响父节点，如果是黑色影响所有路径// 所以 new 的节点为红色cur = new Node(kv);cur->_col = RED;if (parent->_kv.first < kv.first){parent->_right = cur;cur->_parent = parent;}else{parent->_left = cur;cur->_parent = parent;}// 不断向上调整的，所以得用whilewhile (parent && parent->_col == RED){// 父节点是祖父节点的左//      g//    p   u//  c Node* grandfather = parent->_parent;// 1、父节点在祖父的左，即叔叔在右if (parent == grandfather->_left){Node* uncle = grandfather->_right;// 1.1 叔叔存在并且为红if (uncle && uncle->_col == RED){// 变色parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 向上调整cur = grandfather;parent = cur->_parent;}// 1.2 叔叔不存在 / 叔叔存在且为黑，处理方法一样else{if (cur == parent->_left) // 左边高的情况{// 右单旋//     g//   p   u// cRotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else // 左边高右边高的情况{// 双旋//     g//  p     u//    cRotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}// 此时不用祖父位置为黑色不用在网上调整了break;}}// 2、父节点在祖父的右，即叔叔在祖父的左else // parent == grandfather->_right{//     g//   u   p//         cNode* uncle = grandfather->_left;// 2.1 叔叔存在且叔叔为红色if (uncle && uncle->_col == RED){// 变色parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 向上调整cur = grandfather;parent = cur->_parent;}// 2.2 叔叔不存在 / 叔叔存在且颜色为黑，处理方法一样else{if (cur == parent->_right) // 右边高的情况{//     g//   u   p//         cRotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else // 右边高，左边高{//     g//  u     p//      cRotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}// 此时不用祖父位置为黑色不用在网上调整了break;}}}// 最后将根节点变为黑色_root->_col = BLACK;return true;}bool Find(const K& key){Node* cur = _root;while (cur){if (cur->_key < key){cur = cur->_right;}else if (cur->_key > key){cur = cur->_left;}else{return true;}}return true;}bool IsBalance(){if (_root == nullptr) return true;if (_root->_col == RED) return false;// 参考值int refValue = 0;Node* cur = _root;while (cur){if (cur->_col == BLACK) refValue++;cur = cur->_left;}// 检查每条路径黑色节点个数// 思路：以上面参考值为主，对比每条路径的黑色节点个数// 当走到空就说明该路径走完了，那么这个过程中记录下黑色节点个数，到空时与refValue对比// 这里传进去blacknum只能是传值，这样就不会影响上一层的blacknum了int blacknum = 0;// 检查连续红色节点与每条路径黑色节点个数return Check(_root, blacknum, refValue);}size_t Height(){return _Height(_root);}void InOrder(){_InOrder(_root);cout << endl;}private:bool Check(Node* root, int blacknum, const int& refValue){if (root == nullptr){if (blacknum != refValue){cout << "存在黑色节点不相等的路径" << endl;return false;}return true;}// 反向检查，查看当前与父结点为红色(当前节点为红色就说明不是根节点，即存在父节点)if (root->_col == RED && root->_parent->_col == RED){cout << "有连续的红色节点" << endl;return false;}if (root->_col == BLACK) blacknum++;return Check(root->_left, blacknum, refValue)&& Check(root->_right, blacknum, refValue);}// 左单旋void RotateL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;Node* parentParent = parent->_parent;parent->_right = subRL;if (subRL)subRL->_parent = parent;subR->_left = parent;parent->_parent = subR;if (_root == parent) // 父节点就是根节点{_root = subR;subR->_parent = nullptr;}else // 子树情况{if (parentParent->_left == parent){parentParent->_left = subR;}else{parentParent->_right = subR;}subR->_parent = parentParent;}}// 右单旋void RotateR(Node* parent){Node* parentParent = parent->_parent;Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR)subLR->_parent = parent;subL->_right = parent;parent->_parent = subL;if (_root == parent) // 父节点是根节点{_root = subL;subL->_parent = nullptr;}else // 子树情况{if (parentParent->_left == parent){parentParent->_left = subL;}else{parentParent->_right = subL;}subL->_parent = parentParent;}}void _InOrder(Node* pRoot){if (pRoot == nullptr)return;_InOrder(pRoot->_left);cout << pRoot->_data << " ";_InOrder(pRoot->_right);}size_t _Height(Node* pRoot){if (pRoot == nullptr)return 0;int leftHeight = _Height(pRoot->_left);int rightHeight = _Height(pRoot->_right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}private:Node* _root = nullptr;
};

这篇关于[数据结构 - C++] 红黑树RBTree的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/633891。

相关文章

【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
【C++高阶】C++类型转换全攻略：深入理解并高效应用

【C++高阶】C++类型转换全攻略：深入理解并高效应用

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C++ “ 登神长阶 ” 🤡往期回顾🤡：C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝
阅读更多...
C++——stack、queue的实现及deque的介绍

C++——stack、queue的实现及deque的介绍

目录 1.stack与queue的实现 1.1stack的实现  1.2 queue的实现 2.重温vector、list、stack、queue的介绍 2.1 STL标准库中stack和queue的底层结构  3.deque的简单介绍 3.1为什么选择deque作为stack和queue的底层默认容器  3.2 STL中对stack与queue的模拟实现 ①stack模拟实现
阅读更多...
c++的初始化列表与const成员

c++的初始化列表与const成员

初始化列表与const成员 const成员 使用const修饰的类、结构、联合的成员变量，在类对象创建完成前一定要初始化。 不能在构造函数中初始化const成员，因为执行构造函数时，类对象已经创建完成，只有类对象创建完成才能调用成员函数，构造函数虽然特殊但也是成员函数。 在定义const成员时进行初始化，该语法只有在C11语法标准下才支持。 初始化列表 在构造函数小括号后面，主要用于给
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2