C++ - map 和 set 的模拟实现 - 红黑树当中的仿函数 - 红黑树的迭代器实现
简单了解map 和 set 的实现
首先我们要知道，map 和 set 的底层就是 红黑树，但是 STL 当中 ，map 和 set 并不是我们想象的，直接使用一个 pair 对象来存储一个 key-value 或者 是 一个 key。具体如下所示：
set：
在set 当中，只需要存储一个 key 就可以了，因为 set 是 key 的结构。但是在库当中，把 key typedef 了两个值 key_type 和value_type：
map：
在map 当中也是使用了 key_type 和 value_type，但是map 本身就是 key-value 的结构。然后我们又发现，map 的 value_type 又是 使用 pair 类进行封装存储的：
我们在来看 红黑树的 部分源代码：
也就是说，在 map 和 set 当中的值，真正存入 红黑树当中的，其实是 Value。按照上述的说法，set 存入红黑树的是 Key；map 存入红黑树的是 一个 pair 对象，对象当中存储的 是key-value 。
所以，现在你就搞清楚，为什么 set 多搞出来的 key ，和 map 的 Value 为什么要用 pair 来设计，这两者到底用到哪里去了。
而 在STL 当中 的红黑树 的结点类 套了两层，先实现了 __rb_tree_node_base类，这个类当中就是 一个结点的三叉链，还有颜色等等的结点成员， 然后用一个 _rb_tree_node 类 去继承这个类：
此时的 set 或者 map 当中的 key 或者 key-value 就直接通过模版继承到 __rb_tree_node 的 Value 当中了：
也就是说，在红黑树结点类当中，不管传入的是 key 的结构还是 key-value 的结构，都是存储在 红黑树结点类的 Value 当中的，这里利用模版搞了一个泛型。
那么为什么在 set 当中要用 两个 key ，在 map 当中也要和 用一个 key 多在模版当中传如呢？
如上，这个函数在 set 和 map 当中肯定是要实现的，如果我们set当中只有一个 key，在map 当中也是只有 pair 来存储键值对，那么在上述函数调用的时候，对于set 还好，因为 set 的value 就是一个 key ，但是 map 的value是一个pair，pair 如果作为参数来传入这个 find 函数的话，在find（）当中的实现又是直接使用 x 这个key 来实现的，pair 当中的key 要单独访问。所以，map 直接传入 pair 是不行的。
所以，在map 当中就把 key 单独拿出来了，set 为了适配 map，和 map 保持一致，也跟着把 key 单独多列一个出来。
红黑树的代码 和 set，map当中的大体框架
关于红黑树的实现，请看下面这篇博客：
C++ - 红黑树 介绍 和 实现_chihiro1122的博客-CSDN博客
在上述博客当中写的红黑树，其中的就是简单 key-value 结构，用 pair 存储，是写死的。而上述我们修改出来的红黑树就是一个 泛型。红黑树的结点当中的值，不在值存储 pair，还可以支持 set 单独存储 key。
大致结构：
注意，因为上述上述可能需要多个 头文件，如果 头文件在 cpp 文件当中没有包含的话，头文件是不会进行 编译的，那么其中的错误就不会编译出来。
而且，对于 红黑树当中的 insert（）插入函数，其中参数是 插入 value，但是，set 是 key，map 是 key-value，所以，我们这里直接使用 模版参数 T 传入就行：
但是，又遇到了一个大问题，在 insert（）比较函数当中，我们使用的是 key 值来进行比较的，但是 此时 T 的模版参数是 pair 的话，我们之前使用 key 来作为参数比较的规则就不适用了。
这时候，就需要去重载 pair 类的 "<" ">" 运算符 了，其实在 pair 的实现当中官方就已经重载了运算符重载函数：
但是，你仔细观察，其实这里面的比较规则 不是我们想要的比较规则，比如小于：他这里实现的是，first 小 就小，否则，second 小就小。 但是我们只期望用 key 来比。
库当中已经实现了，所以，这里我们不能直接去重载 pair 当中的 大于小于运算符重载函数，参数也是一样的，两者之间不好重载。
所以，这里我们就要使用仿函数的方式去实现。仿函数的博客可以看以下博客：C++ - 优先级队列（priority_queue）的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_c++ priority_queue迭代器_chihiro1122的博客-CSDN博客
但是，在上述优先级队列当中实现的仿函数，该仿函数的功能是比较大小；但是在红黑树当中的仿函数不是比较大小。
在 库当中的红黑树，还有一个 参数是 KeyOfValue：
这个 KeyOfValue 模版参数意思就是把 value 当中的 key 取出来。
所以，我们要想 优先级队列当中仿函数的使用规则一样，把仿函数的类通过模版参数传入进去。
因为 ，这个 仿函数的类不是写给用户来控制的，是写给 map 和set 来使用的，所以，关于仿函数的类我们可以直接在 set 和 map 当中使用内部类来构造，关于 set 和 map 的内部类仿函数构造如下：
set：
#pragma once
#include"RBTree.h"
namespace Mynamespace
{
template
class set
{
struct SetKeyOfT
{
// 和 map 对照的标准写法
//const k& operator()(const pair& kv)
//{
// return p.first;
//}
// 其实可以直接这样写
const k& operator()(const K& key)
{
return key;
}
};
private:
RBTree _t;
};
} map：
#pragma once
#include"RBTree.h"
namespace Mynamespace
{
template
class map
{
struct MapKeyOfT
{
const k& operator()(const pair& kv)
{
return p.first;
}
};
private:
RBTree , MapKeyOfT> _t;
};
} 两者的仿函数的返回值都是把 set 的 key 和 map 的pair里的key 取出来，作为函数的返回值返回。
这样的话，我们就可以在 红黑树的 insert（）函数当中，使用仿函数来取出 对应的 key 值，然后进行key 值的比较了。
红黑树当中对仿函数的调用如下例子：
这里就调用 kot 对象当中的仿函数，把 _data 当中的 key 值取出来，如果这个 _data 是set 的，那么 key 就是直接返回，如果是 map 的，就需要从 pair 当中取出。
这里之所以不想之前，在优先级队列当中的仿函数一样直接仿函数的那种进行比较，因为我们直接在仿函数当中进行比较的话，不好进行比较，不清楚到底怎样取出 key 。只有像上述一样，写两个仿函数的类，然后通过模版参数，知道此时我需要怎样取出 key 值。
这一个仿函数只实现 取出 key 的功能，是因为要和 比较方式分离，如果我们在 取出 key 的仿函数当中就把 如何比较 实现了，当然是可以的，但是，如果这样做的话，相当于是把比较方式写死了，如果我们想要用 仿函数的方式来在 set 和 map 当中进行 区别比较方式的话，那么在 set 和map 的模版参数当中就需要再实现一个 区别 比较方式的 仿函数类。
但是，对于 我们刚刚实现的 MapKeyOfT 和 SetKeyOfT 这两个仿函数类，如果是单独使用 set 和 map 的人是不会关心的，因为这两个仿函数是供给 内部用的，外部根本就不需要。所以我们发现，在官方库的 红黑树当中 除了 有一个 控制 取出不同key 的方式的仿函数之外，还有一个 控制比较方式的仿函数，这样就控制在 内部了（树一层）。
看一个例子就明白了：
如上述的 find（）函数当中的比较，就是 _data 和 key 的比较；而在 insert（）当中的比较就是 _data 和 _data 的比较，两种比较的方式就不一样的，不能单独的直接写死，如果我又想用仿函数去控制的话，那么比较的方式这么多，得写多少仿函数。
所以，库当中使用的是 两种 仿函数，一个吧 key 值取出的方式（set 和 map 不同）取出，然后直接在外部比较 key 值就行了，而且只用控制 除了 （取出 key 值不同的之外的 比较方式。如：大于小于的不同，和 key + value的比较方式）
u而 set 当中的 返回的就是 key ，其实 本身就是可以比较的，但是为了和 map 构成泛型，要多调用一次仿函数。
如上图所示，是库当中 红黑树的 模版参数，发现还有一个 Compare 参数，这个就是用来控制比较方式的 仿函数。
红黑树的代码：
#pragma once
#include
using namespace std;
// 节点的颜色
enum Colour
{
RED,
BLACK
};
template
struct RBTreeNode
{
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
T _data;
Colour _col;
RBTreeNode(const T& data)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _data(data)
, _col(RED)
{}
};
template
struct __TreeIterator
{
typedef RBTreeNode Node;
typedef __TreeIterator Self;
Node* _node;
__TreeIterator(Node* node)
:_node(node)
{}
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
Self& operator--();
Self& operator++()
{
// 此时就是最简单的情况
// 直接找出该结点的右子树的最小结点
if (_node->_right)
{
// 右树的最左节点(最小节点)
Node* subLeft = _node->_right;
while (subLeft->_left)
{
subLeft = subLeft->_left;
}
_node = subLeft;
}
else //_node->_left
{
Node* cur = _node;
Node* parent = cur->_parent;
// 找孩子是父亲左的那个祖先节点，就是下一个要访问的节点
while (parent)
{
if (cur == parent->_left)
{
break; // 说明已经找到，parent此时就是下一次需要迭代的结点
}
// 如果程序走到这里，该结点和 父亲结点的左右子树都遍历完了
// 就要往上迭代
// 直到找到 父亲 的右子树没有找完的情况
else //cur == parent->_right
{
cur = cur->_parent;
parent = parent->_parent;
}
}
_node = parent;
}
return *this;
}
};
// set->RBTree _t;
// map->RBTree, MapKeyOfT> _t;
// 红黑树节点的定义
template
struct RBTree
{
typedef RBTreeNode Node;
public:
typedef __TreeIterator iterator;
// const_iterator
iterator begin()
{
Node* leftMin = _root;
// 加上 subleft 这个条件是为了防止 这棵树是空
while (leftMin && leftMin->_left)
{
leftMin = leftMin->_left;
}
return iterator(leftMin);
}
iterator end()
{
// end（）不用像上述一样 找最大值
// 通过迭代器当中的 operator++（）函数我们知道，中序最后都是遍历到 nullptr 的
// 这个 nullptr就是 根结点的父亲指针指向的 nullptr
return iterator(nullptr);
}
Node* Find(const K& key)
{
Node* cur = _root;
KeyOfT kot;
while (cur)
{
if (kot(cur->_data) < key)
{
cur = cur->_right;
}
else if (kot(cur->_data) > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}
bool Insert(const T& data)
{
// 搜索二叉树的插入逻辑
//
// 如果当前树为空，直接用头指针只想新结点
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return true;
}
// 不为空接着走
Node* parent = nullptr; // 用于首次插入时候指针的迭代
Node* cur = _root;
KeyOfT kot;
while (cur)
{
// 如果当前新插入的 key 值比 当前遍历的结点 key 值大
if (kot(cur->_data) < kot(data))
{
// 往右迭代器
parent = cur;
cur = cur->_right;
}
// 反之
else if (kot(cur->_data) > kot(data))
{
parent = cur;
cur = cur->_left;
}
else
{
// 如果相等，就不插入，即插入失败
return false;
}
}
// 此时已经找到 应该插入的位置
cur = new Node(data);
cur->_col = RED;
// 再次判断大小，判断 cur应该插入到 parent 的那一边
if (kot(parent->_data) < kot(data))
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
// 链接 新插入结点 cur 的_parent 指针
cur->_parent = parent;
// 红黑树调整高度（平衡高度）的逻辑
while (parent && parent->_col == RED)
{
// parent 为 红，parent->_parent 一定不为空
Node* grandfather = parent->_parent;
// 如果父亲是在 祖父的左
if (parent == grandfather->_left)
{
Node* uncle = grandfather->_right;
// u存在且为红
if (uncle && uncle->_col == RED)
{
// 变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
// 继续向上处理
cur = grandfather;
parent = cur->_parent;
}
else // u不存在 或 存在且为黑
{
if (cur == parent->_left)
{
// g
// p
// c
RotateR(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
// g
// p
// c
RotateL(parent);
RotateR(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;// 不需要再往上更新
}
}
else // parent == grandfather->_right
{
Node* uncle = grandfather->_left;
// u存在且为红
if (uncle && uncle->_col == RED)
{
// 变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
// 继续向上处理
cur = grandfather;
parent = cur->_parent;
}
else// 不存在 或者 存在且为黑色
{
if (cur == parent->_right)
{
// g
// p
// c
RotateL(grandfather);
grandfather->_col = RED;
parent->_col = BLACK;
}
else
{
// g
// p
// c
RotateR(parent);
RotateL(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
// 不管上述如何修改，红黑树的根结点永远是黑的
// 所以我们这里既直接硬性处理
_root->_col = BLACK;
return true;
}
void RotateL(Node* parent)
{
Node* cur = parent->_right; // 存储 parent 的右孩子
Node* curleft = cur->_left; // 存储 cur 的左孩子
parent->_right = curleft;
if (curleft) // 判断 cur 的左孩子是否为空
{
curleft->_parent = parent; // 不为空就 修改 cur 的左孩子的_parent 指针
}
cur->_left = parent;
// 留存一份 根结点指针
Node* ppnode = parent->_parent;
parent->_parent = cur;
// 如果parent 是根结点
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else
{
if (ppnode->_left == parent)
{
ppnode->_left = cur;
}
else
{
ppnode->_right = cur;
}
cur->_parent = ppnode;
}
}
void RotateR(Node* parent)
{
Node* cur = parent->_left;
Node* curRight = cur->_right;
parent->_left = curRight;
if (curRight)
{
curRight->_parent = parent;
}
cur->_right = parent;
Node* ppnode = parent->_parent;
parent->_parent = cur;
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else
{
if (ppnode->_left == parent)
{
ppnode->_left = cur;
}
else
{
ppnode->_right = cur;
}
cur->_parent = ppnode;
}
}
bool CheckColor(Node* root, int blacknum, int benchamark)
{
// 当走到叶子结点的 null 指针处，也就是 NIL结点处
if (root == nullptr)
{
// 如果计算出的路径黑色结点长度 和 外部计算的不一样
// 说明不是红黑树
if (blacknum != benchamark)
{
cout << "路径黑色结点个数不一样" << endl;
return false;
}
return true;
}
// 用于递归计算 路径的黑色结点个数
if (root->_color == BLACK)
blacknum++;
// 如果当前结点为 红色，且当前结点的父亲也是红色，就不是红黑树
if (root->_parent && root->_parent->_color == RED && root->_color == RED)
{
cout << "有连续红色" << endl;
return false;
}
// 左右子树递归
return CheckColor(root->_left, blacknum, benchamark)
&& CheckColor(root->_right, blacknum, benchamark);
}
// 外部调用接口
bool isBalance()
{
return isBalance(_root);
}
// 内部封装函数
bool isBalance(Node* root)
{
if (root == nullptr)
return true;
// 如果整棵树的 根结点不是 黑色的就不是红黑树
if (root->_color != BLACK)
{
cout << "根结点不是黑色" << endl;
return false;
}
// 基准值
// 在递归外部计算出左路第一条路径的 黑色结点值
int benchmark = 0;
Node* cur = root;
while (cur)
{
if (cur->_color == BLACK)
benchmark++;
cur = cur->_left;
}
return CheckColor(root, 0, benchmark);
}
private:
Node* _root = nullptr;
}; 红黑树的迭代器
二叉搜索树的遍历无非就是 中序遍历，但是，在迭代器实现当中还有 operator++（）和 operator--（）这些函数，比如说 ++ 该如何实现呢？
框架和一些简单函数实现
// 红黑树迭代器的实现
template
struct __Treeiterator
{
typedef RBTreeNode Node;
typedef __Treeiterator Self;
Node* _node;
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
bool operator!=(const Self& s)
{
return _node == s._node;
}
} begin（） 和 end（）
一个迭代器的基本使用方式无非就是下述的使用方式：
那么，首先我们要找到 begin（）和 end（）指向的位置。begin（）在二叉搜索树当中就是中序遍历结果 第一个值，那么就是 这个树当中的最小值，所以就是 这棵树的最左边那个结点的值；而 edn（）就是 最右边的结点的值了。
end（）不用像上述一样 找最大值，通过迭代器当中的 operator++（）函数我们知道，中序最后都是遍历到 nullptr 的，这个 nullptr就是 根结点的父亲指针指向的 nullptr。
typedef __Treeiterator iterator;
iterator begin()
{
Node* subleft = _root;
// 加上 subleft 这个条件是为了防止 这棵树是空
while (subleft && subleft->left)
{
subleft = subleft->_left;
}
return iterator(subleft);
}
iterator end()
{
// end（）不用像上述一样 找最大值
// 通过迭代器当中的 operator++（）函数我们知道，中序最后都是遍历到 nullptr 的
// 这个 nullptr就是 根结点的父亲指针指向的 nullptr
return iterator(nullptr);
} operator++（）函数
而，对于++函数，如下图所示：
假设 it 此时是指向 8 的，那么此时要对 it迭代器 ++，那么就应该去找 8 的右子树的最小结点，也就是右子树的 最左结点。
如果 it 指向 5 ，此时 it迭代器要 ++，就要分两种情况（因为中序的是左子树 根 右子树，所以看 右子树是否为空）：
右不为空，就要去访问右子树当中最左边的结点（最小结点）。
右不为空，此时说明该结点已经访问完了，要访问祖先，注意不是 不一定是父亲，应为此时 该结点可能为父亲的左 也有可能为 父亲的右，如果为父亲的左说明 父亲还没有访问结束，那么就访问父亲；如果 该结点是父亲的右，说明父亲已经访问完了，此时就要访问父亲的父亲。
operator++（）函数代码：
Self& operator++()
{
// 此时就是最简单的情况
// 直接找出该结点的右子树的最小结点
if (_node->_right)
{
Node* subleft = _node->_right;
while (subleft->_left)
{
subleft = subleft->_left;
}
_node = subleft;
}
else //_node->_left
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent)
{
if (cur == parent->_left)
{
break; // 说明已经找到，parent此时就是下一次需要迭代的结点
}
// 如果程序走到这里，该结点和 父亲结点的左右子树都遍历完了
// 就要往上迭代
// 直到找到 父亲 的右子树没有找完的情况
else //cur == parent->_right
{
cur = cur->parent;
parent = parent->_parent;
}
}
_node = parent;
}
}模拟实现set
insert（）：
直接套用 红黑树当中的 insert（）函数：
public:
bool insert(const T& key)
{
// 因为底层是哟个红黑树实现的，直接套用红黑树的 插入
return _t.insert(key);
}迭代器
因为，set 和 map 的底层都是用红黑树来实现的，在红黑树当中已经实现了 迭代器，那么我们完全可以使用 红黑树当中的迭代器来复用在 set 和 map 当中。
public:
typedef typename RBTree::iterator iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
} 注意：上述 使用了 typename 关键字修饰：
是因为，RBTree
而且，set 当中只存储 key ，所以不允许利用 *it = 10 这样的方式来对 set 当中的key 进行修改。
库当中的实现方式非常简单，就是无论是否是 const 的 迭代器都 认为是 const 的迭代器，也就是说其实 在 set 当中就一个迭代器，只有一个 const 的迭代器：
模拟实现 map
insert（）：
public:
bool insert(const T& key)
{
// 因为底层是哟个红黑树实现的，直接套用红黑树的 插入
return _t.insert(key);
}迭代器
public:
typedef typename RBTree, MapKeyOfT>::iterator iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
} map 当中 允许修改 value 但是不允许修改 key ，所以，map 当中不能像 set 当中一样，只实现一个 const 迭代器，在map 当中的迭代器还是正常的：
map 是在存储层解决这个问题的：
他的 T 都是好的，但是key 是 const 的。
意思就是当我们在外部取到 first 的时候，这个 first 就是一个 const 修饰的值，不能进行修改了;
