【C++】红黑树详解（附迭代器以及插入实现），适合初学者
文章目录
- 什么是红黑树
- 红黑树的性质
- 节点结构
- 节点插入的情况分析
- 红黑树的检验
- 迭代器
-
- 顺序遍历 Increament
- 逆序遍历 DeIncreament
- 迭代器代码一览
- 制造map/set
- 总结
什么是红黑树
- 红黑树作为一种二叉搜索树，在于一些查找方面，红黑树能提高较高的查找效率。并且对比起AVL高度平衡二叉搜索树有着更少的旋转的特性，而更少的旋转能够带来更高的效率，所以C++的map/set底层，以及Linux的内核都倾向于使用红黑树。
- 红黑树的节点是由颜色来区分的，而这个颜色也正是红黑树能够减少旋转的一个重要因素。
红黑树的性质
-
- 每个结点不是红色就是黑色
-
- 根节点是黑色的
-
- 如果一个节点是红色的，则它的两个孩子结点是黑色的
-
- 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
-
- 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
对于性质的分析，为何满足性质就能够减少旋转的次数，且能够保持最长的路径不会超过最短路径的两倍？
原因：
- 首先每条路径上的黑节点树要相同，那就意味着去除掉红节点，我们所看到一定是一颗满二叉树，
- 而红色节点必须父亲与左右节点都是黑色节点，这条性质保证了最长路径一定是黑红黑红…排列的而此时黑色节点和红色节点的数量是一致的。
- 而最短路径就是只出现黑色节点的路径，此时最长路径肯定最多是最短路径的两倍。
注意：这里的条件五叶子节点所指的是空节点，更准确地说是nil空节点，路径是以到nil叶子节点为止的。
节点结构
节点采用三叉链，与保存的值，以及一个标识颜色的整形常数组成。（后面会更改）
enum Color
{
RED,
BLACK
};
template<class K,class V>
class RBTreeNode
{
public:
RBTreeNode(const pair<K,V>& kv)
:_col(RED)
,_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
{
_kv = kv;
}
Color _col;
RBTreeNode<K,V>* _left;//左节点
RBTreeNode<K,V>* _right;//右节点
RBTreeNode<K,V>* _parent;//父节点
std::pair<K, V> _kv; //节点的值
};
节点插入的情况分析
首先需要解决一个问题，节点一开始给什么颜色呢？
给黑色的话会造成条件4不成立，需要对除添加节点所在路径以外的所有路径做修改，这未免也太麻烦了，所以我们采用的是插入红色节点，这样子最多破坏了规则三，而我们可以通过只修改当前路径的方式解决。
若插入的节点的父节点是黑色节点，就已经成功了，接下来考虑要变化的。
- 情况一：插入节点的叔叔节点为红
cur可能是由于下层的节点将黑色改成红色造成的，也有可能是新插入节点，为了解决这种情况，我们采用的方式是将p节点和u节点的颜色置成黑色，g节点置成红色，此时g就作为新插入的节点向上寻找。
if (uncle && uncle->_col == RED)
{
//情况一：优先判断，这种情况处理方式更简单
uncle->_col = parent->_col = BLACK;
g->_col = RED;
//向上迭代，此时g相当于新插入节点
//这个很重要
parent = g->_parent;
newNode = g;
continue;
}
结束条件：
-
已经更新到根节点。
-
父节点是黑色的。
-
情况二：当uncle节点为NULL或者uncle节点不存在-
两种情况具体分析： -
uncle节点为黑的情况，一定是因为cur节点是新插入节点，否则cur所在路径上的黑色节点与u所在路径的黑色节点不相同，说明cur下的a，b节点各自有着黑色节点。
-
uncle不存在的情况则cur一定是新增节点，此时c，u，cur一定都是nil，随后cur插入进来。
解决方案：
旋转+更改颜色解决，由于路径上已经无法将红色节点处理了，原因就是红色节点所处的位置占据的不对，此时我们肯定不能删除红色节点，毕竟他保存着也是有效的数据。
此时将g节点作为分支中的一条，将底下的节点作为根，且置成黑色，既保证了每条路径的黑节点数量相同，也解决了红色节点与红色节点接触的问题。
if (parent->_left == newNode)
{
//右单旋
RotateR(g);
parent->_col = BLACK;
g->_col = RED;
}
else
{
//左右双旋
RotateL(parent);
RotateR(g);
newNode->_col = BLACK;
g->_col = RED;
}
左旋和右左双旋同理。比起AVL的旋转，其实难度差不多。
红黑树的检验
- isRRTree函数证明是否有红色与红色节点相连接。
- RBDistance用于检测每条路径上的黑色节点数目是否相同。
- rbOrder用于检测节点中序遍历是否是有序的。
public:
bool IsRBTree()
{
bool rr = isRRTree(_head);
int beach = 0;
Node* cur = _head;
while (cur)
{
if(cur->_col == BLACK)
beach++;
cur = cur->_left;
}
bool rbdistance = RBDistance(_head,beach,0);
bool order = rbOrder();
return rr && rbdistance && order;
}
private:
bool isRRTree(Node* head)
{
if (head == nullptr)
return true;
if (head->_col == RED)
{
if (head->_left && head->_left->_col == RED)
{
cout << "红色与红色相连接" << endl;
return false;
}
if (head->_right && head->_right->_col == RED)
{
cout << "红色与红色相连接" << endl;
return false;
}
}
return isRRTree(head->_left) && isRRTree(head->_right);
}
bool RBDistance(Node * head, int beach, int count)
{
if (head == nullptr)
{
if (count != beach)
{
cout << "每条路径的黑色节点不相同" << endl;
return false;
}
return true;
}
return RBDistance(head->_left, beach, head->_col == BLACK ? count + 1 : count)
&& RBDistance(head->_right, beach, head->_col == BLACK ? count + 1 : count);
}
bool rbOrder()
{
stack<Node*> st;
Node* cur = _head;
while (cur)
{
st.push(cur);
cur = cur->_left;
}
Node* pre = nullptr;
while (!st.empty())
{
Node* top = st.top();
st.pop();
if (pre && pre->_kv.first > top->_kv.first)
{
cout << "不是有序的" << endl;
return false;
}
top = top->_right;
while (top)
{
st.push(top);
top = top->_left;
}
}
return true;
}
迭代器
在讲述迭代器的时候，首先得说明，红黑树的结构并不是像上面的图所示，而是拥有一个哨兵位头结点的。
以下例子对于两个节点的称呼：header即为哨兵位头节点，8即为根节点
细节说明：
- 头节点的左指针指向的是最左节点（也就是最小节点 - - leftMost）
- 头节点的右指针指向最右节点（也就是最大节点 - - rightMost）
- 头节点的父亲节点指向的是根节点
为什么需要添加一个头节点方便进行迭代器设计呢？
个人认为最重要的原因在于节点遍历的时候倘若没有头节点，那么在operator++，operator–的两个逻辑当中不能采用同一套设计来实现，当没有头节点，我们只能将leftMost设置begin，而end只能放在根节点的父亲，也就是NULL，正序遍历的时候正好可以全部遍历完；但是当出现了从end()遍历到begin（）位置，这样的设计就不能满足要求了。
上面这么说，那么加入迭代器肯定就能解决了！当倒叙遍历时，header只需要特判一下自己是不是头节点，如果是就跳转到rightMost，此时遍历到begin（）也就简单了。
begin() 指向的是leftMost，end（）指向的是头节点。
并且有一处设计的比较巧妙，就是将头节点的颜色设置成红色，由于头节点和根节点都能够通过 xx->_parent->_parent找到自己，并且根节点必须为黑色，所以我们要将两个节点进行区分，就选择将头节点的颜色设置成红色。
注意:添加头节点导致插入的判断条件发生变化
- 添加了哨兵位插入的逻辑需要稍微变化
while (parent->_col == RED && parent != _head )//parent->parent，因为此时有可能出现插入可能出现uncle为红色的情况，此时parent会走到头节点。 - 并且Insert函数需要每次插入更新leftMost以及rightMost。
顺序遍历和逆序遍历都以该图为基础
顺序遍历 Increament
顺序遍历的时候实际上走的是一个中序遍历，即左根右形式，那么当我们在当前节点，有如下几种情况。
- 1.右节点存在，如11这个节点，此时我们应当访问右节点的最左节点。
- 2.当右节点不存在，我们首先都需要向上面遍历，并找到
当前访问节点是父亲节点的左孩子的情况。 - 2.1 但是此时有特殊情况，当根节点没有右孩子的时候，若节点已经遍历到根位置，但同时就是rightMost，若外面使用迭代器遍历就会陷入死循环。
- 2.2 若有右孩子，就不会有上述问题。此时_node(迭代器封装的指针)到达了头节点的位置，正常遍历完，而pre在根节点的位置，此时恰好也不满足_node->_right == pre的条件，所以while循环结束，且_node也到达了end()的位置，遍历结束。
void Increament()
{
//右节点存在
if (_node->_right)
{
_node = _node->_right;
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
//右节点不存在
Node* pre = _node;
_node = _node->_parent;
while (_node->_right == pre)
{
pre = _node;
_node = _node->_parent;
}
//特殊情况分析，与内核实现不同，我是定义前指针，源代码是父指针，这种情况当头节点没有右孩子的时候，头节点会在同一个位置死循环
//所以加上后面的条件解决这种情况。
if (pre->_right == _node)
{//根节点没有右孩子
_node = pre;
}
}
}
逆序遍历 DeIncreament
逆序遍历正好与中序遍历相反，即右根左的顺序。
遍历情况：
1.若左节点存在，如8位置，则访问左节点的最右节点；
2.若左节点不存在，如12位置，就访问头节点的位置是当前节点位置的右孩子的位置，即11位置。
特殊情况：
我们一开始从end()位置出发，此时我们想要遍历的第一个元素是rightMost元素，而根据上面的遍历情况我们会走到leftMost位置，，所以这个时候我们可以判断是否当前位置为头节点，_node->_parent->_parent == _node && _node->_col == RED，此时上面所说的头节点的颜色为红色的情况也就用上了。
void DeIncreament()
{
//通过虚拟头节点的颜色辨别是头节点还是虚拟节点，太优雅了。
if (_node->_parent->_parent == _node && _node->_col == RED)
{
_node = _node->_right;
return;
}
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
else
{
Node* pre = _node;
_node = _node->_parent;
while (_node->_left == pre)
{
pre = _node;
_node = _node->_parent;
}
}
}
迭代器代码一览
template<class T>
class RBTreeIterator
{
typedef RBTreeNode<T> Node;
typedef RBTreeIterator<T> Self;
private:
Node* _node;
public:
RBTreeIterator(Node* node)
:_node(node)
{}
bool operator!=(const Self& it)
{
return _node != it._node;
}
bool operator==(const Self& it)
{
return _node == it._node;
}
T* operator->()
{
return &(_node->_data);
}
Self& operator++()
{
Increament();
return *this;
}
Self& operator--()
{
DeIncreament();
return *this;
}
void Increament()
{
if (_node->_right)
{
_node = _node->_right;
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
Node* pre = _node;
_node = _node->_parent;
while (_node->_right == pre)
{
pre = _node;
_node = _node->_parent;
}
//特殊情况分析，与内核实现不同，我是定义前指针，源代码是父指针，这种情况当头节点没有右孩子的时候，头节点会在同一个位置死循环
//所以加上后面的条件解决这种情况。
if (pre->_right == _node)
{
_node = pre;
}
}
}
void DeIncreament()
{
//通过虚拟头节点的颜色辨别是头节点还是虚拟节点，太优雅了。
if (_node->_parent->_parent == _node && _node->_col == RED)
{
_node = _node->_right;
return;
}
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
else
{
Node* pre = _node;
_node = _node->_parent;
while (_node->_left == pre)
{
pre = _node;
_node = _node->_parent;
}
}
}
T& operator*()
{
return _node->_data;
}
};
制造map/set
- 封装map，首先得更改Insert的返回值为pair
- 由于在Insert函数内部需要获取节点值当中的key值，但是在RBTree当中，他并不知道他被封装的是map还是set，所以此时需要在map/set当中传入第三个模板参数KOft，表示从节点获取Key值的方法。同时，这也决定了第一个参数传K，第二个参数传T。因为K可以在FInd函数当中使用，而T才是节点的值真正的类型。
所以set封装时，节点的值为const K，而map封装的时候节点的值时pair RBTree，typedef typename RBTree由于节点是通过第二个参数传递，所以我们在map或set都可以将K设置为const，避免RBtree当中对K进行修改。- map想要实现operator[]，此时只需要
return (insert(make_pair(key,V())).first)->second;直接调用插入是因为插入函数当存在时会返回红黑树节点的迭代器，不存在正好可以插入。
注意点：
- 由于红黑树当中的节点的值被设置成了const K，而pair赋值又是一个值一个值的赋值，但是在构造函数内部赋值此时无法对const 类型做修改，所以得在初始化列表初始化。
typedef RBTreeIterator,typedef typename RBTreemap中设置迭代器的两种方式，由于RBTree
RBTree2.hpp
#pragma once
#include string 之类的
template<class T>
class RBTreeNode
{
public:
//const std::pair& data
RBTreeNode(const T& data)
:_col(RED)
,_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_data(data)
{
//若加上了这个const K ，由于pair赋值 的时候是一个个赋值，由于const K不能被赋值，所以必须放在初始化列表处初始化，否则会报错
//_data = data;
}
Color _col;
RBTreeNode<T>* _left;
RBTreeNode<T>* _right;
RBTreeNode<T>* _parent;
T _data;//std::pairmap.hpp
#pragma once
#include iterator;
//两种方式，但是下面这种由于模板没有实例化所以需要加typename
typedef typename RBTree<K, pair<const K, V>, KOft>::iterator iterator;
public:
iterator begin()
{
return _map.begin();
}
iterator end()
{
return _map.end();
}
V& operator[](const K& key)
{
//找不到就插入
//方法1：
//iterator result = _map.find(key);
//if(result == end())
//{
// std::pair it = insert(std::make_pair( key,V()) );
// return it.first->second;
//}
//return result;
//方法2：
return (insert(make_pair(key,V())).first)->second;
}
pair<iterator,bool> insert(const pair<const K,V>& kv)
{
return _map.Insert(kv);
}
};
void test_map()
{
map<string, string> dict;
dict.insert(make_pair("sort", ""));
dict.insert(make_pair("string", ""));
dict.insert(make_pair("debug","a"));
dict.insert(make_pair("set", ""));
dict["make"];
dict["debug"] = "x";
dict["insert"] = "";
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
cout << it->first << ":" << it->second << endl;
++it;
}
cout << endl;
}
}
//严重性 代码 说明 项目 文件 行 禁止显示状态
//错误 C2280 “std::pair& std::pair::operator =(volatile const std::pair&)”: 尝试引用已删除的函数 RBTree C : \Users\asus\source\repos\RBTree\RBTree\RBTree2.h 24
set.hpp
#pragma once
#include总结
gitee链接：https://gitee.com/wuyi-ljh/test-43—testing/tree/master/RBTree3