【C++】用红黑树封装set和map

在C++标准库中，set容器和map容器的底层都是红黑树，它们的各种接口都是基于红黑树来实现的，我们在这篇文章中已经模拟实现了红黑树 ->【C++】红黑树，接下来我们在此红黑树的基础上来看看如何封装set和map。

一、共用一颗红黑树

我们在这篇文章中 ->【C++】set容器和map容器的基本使用，清楚set是key搜索场景的结构，map是key/value搜索场景的结构。所以要用红黑树封装它们两个就需要2棵红黑树，这两颗红黑树整体逻辑差不多一样，只是结点中的元素数据类型不一样，一个是K类型，一个是pair<K,V>类型。两棵极为相似的树，只是一点不同，如果实现两个会显得冗余，那么我们就可以考虑使用模板来将结点中的数据类型泛型化，使set和map底层共用一个红黑树。

我在先前的文章中已经实现了红黑树，它是解决key/value搜索场景的，我将那篇文章的源代码裁剪了一些重要的部分，大家这里只需看懂这部分的功能：

template<class K, class V>
struct RBTreeNode
{pair<K, V> _kv;RBTreeNode<K, V>* _left;RBTreeNode<K, V>* _right;RBTreeNode<K, V>* _parent;	Colour _col;RBTreeNode(const pair<K, V>& kv):_kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr){}
};template<class K, class V>
class RBTree
{typedef RBTreeNode<K, V> Node;
public: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;elsereturn false;}cur = new Node(kv);cur->_col = RED; if (parent->_kv.first < kv.first)parent->_right = cur;elseparent->_left = cur;cur->_parent = parent;while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK; grandfather->_col = RED;}else {RotateL(parent);RotateR(grandfather);cur->_col = BLACK;  grandfather->_col = RED;}break; }}else  {Node* uncle = grandfather->_left;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_right){RotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else {RotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}}_root->_col = BLACK;return true;}
private:Node* _root = nullptr; 
};

此时，结点中数据类型是pair，这样我们就把这个结点的数据类型写"死"了，set容器底层就不能用这个红黑树，我们要实现set和map共用一棵红黑树，所以就需要把结点的数据类型泛型化(根据传来的类型来确定具体的类型)：

template<class T>  //如果是set就传K，如果是map就传pair<K,V>
struct RBTreeNode
{T _data;RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;	Colour _col;RBTreeNode(const T& data):_data(data), _left(nullptr), _right(nullptr), _parent(nullptr){}
};

那么，RBTree也要跟着改：

template<class T>
class RBTree
{typedef RBTreeNode<T> Node;
public:bool Insert(const T& data){if (_root == nullptr){_root = new Node(data);_root->_col = BLACK;return true;}Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_data.first < data.first)parent = cur,cur = cur->_right;else if (cur->_data.first > data.first)parent = cur,cur = cur->_left;elsereturn false;}cur = new Node(data);cur->_col = RED; if (parent->_data.first < data.first)parent->_right = cur;elseparent->_left = cur;cur->_parent = parent;while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK; grandfather->_col = RED;}else {RotateL(parent);RotateR(grandfather);cur->_col = BLACK;  grandfather->_col = RED;}break; }}else  {Node* uncle = grandfather->_left;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_right){RotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else {RotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}}_root->_col = BLACK;return true;}
private:Node* _root = nullptr; 
};

封装set：

//MySet.h
#include "RBTree.h"
namespace blue
{template<class K>class set{public:bool insert(const K& key){return _t.Insert(key);}private:RBTree<K> _t;};
}

封装map：

//MyMap.h
#include "RBTree.h"
namespace blue
{template<class K,class V>class map{public:bool insert(const pair<K, V>& kv){return _t.Insert(kv);}private:RBTree<pair<K, V>> _t;};
}

这样我们就可以通过模板参数T来控制set和map共用一棵红黑树了！

二、 红黑树中Insert带来的问题

通过观察上面红黑中Insert中的代码，其实会有问题：

我们的data可能是K类型，也可能是pair<K,V>类型。如果是后者，那么这样比较当然没问题，那如果是前者，就不能这样比较，所以我们要对这个部分进行修改。

怎么修改呢？去掉.first吗？

我们如果去掉.first，那么不管是K还是pair<K,V>都可以进行比较，以pair<K,V>类型为例，两个pair类型进行比较时先比较K，如果K相同则比较V，这与我们的本意相违背，我们的要求是只比较K的值，不能让V的值参与比较！所以我们要解决问题，不能仅仅是去掉.first。

我们可以在set和map类中写一个仿函数，通过仿函数来获取K，具体做法如下：

#include "RBTree.h"
namespace blue
{template<class K>class set{struct KeyOfSet{const K& operator()(const K& key){return key;}};public:bool insert(const K& key){return _t.Insert(key);}private:RBTree<K,KeyOfSet> _t;};
}#include "RBTree.h"
namespace blue
{template<class K,class V>class map{struct KeyOfMap{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:bool insert(const pair<K, V>& kv){return _t.Insert(kv);}private:RBTree<pair<K, V>,KeyOfMap> _t;};
}

 这时我们就需要在红黑树中加一个模板参数：

我们明确知道map是需要这个仿函数来获取K值的，但是在set中也写一个仿函数来获取K值，有人开始会觉得这是多余的，因为set中的元素类型本身就是K类型，但是不要忽略一点，set和map是共用同一份模板的，map需要这个仿函数，那么set也必须有这个仿函数，set这里的仿函数就是为了兼容map，这时，红黑树的第二个模板参数KeyOfT就出现了。

三、erase和find带的来问题

我们知道set容器和map容器都有erase和find接口，这两个接口都是根据K值来进行的，如果我们要在红黑树中实现这两个接口那么必须知道K的值，我们根据K的值来进行删除和查找。但是现在，我们自己实现的这个红黑树中并没有办法拿到K的值，也就是说在我们目前这棵红黑树中若要实现erase和find是做不到的！

为了获取K的值，我们可以在RBTree中再添加一个模板参数K，专门用来获取K的值：

在set中：

在map中：

其实，这里的set中传了两个K，第一个K就是兼容map的。因为map需要这个K，那么在TRBTree中就必须增加一个模板参数，所以set就必须传一个K。

那么在RBTree中erase和find接口就可以这样写：

bool find(const K& key)
{//...
}bool erase(const K& key)
{//...
}

 四、迭代器

红黑树的迭代器和我们在模拟实现list时思路是一样的，因为红黑树的底层空间是不连续的，所以我们不能直接"typedef Node* iterator"，我们要单独用一个类型封装结点的指针，再通过重载运算
符实现，让迭代器具有像指针一样访问的行为：

//Ref和Ptr是为了兼容普通迭代器和const迭代器
template<class T,class Ref,class Ptr>
struct RBTreeIterator
{typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, Ref, Ptr> Self;Node* _node; //当前结点指针RBTreeIterator(Node* node):_node(node){}Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}bool operator==(const Self& s){return _node == s._node;}bool operator!=(const Self& s){return _node != s._node;}
};

因为set和map都是双向迭代器，所以它们的迭代器应该要支持++和--操作，由于它们的迭代器是复用红黑树的，所以红黑树中的迭代器也要实现++和--操作，list迭代器的++或--操作实现起来非常简单，只需利用next指针就好；反观红黑树，它的++/--操作要求必须满足中序遍历规则，红黑树的中序遍历是有序的，假设某棵红黑树的中序遍历是"1   3    5    6    7   9" ，如果迭代器在3这个位置，那么++后就必须到5，--后就必须到1。迭代器++的核心逻辑就是不看全局，只看局部，只考虑当前中序局部要访问的下⼀个结点。

那么如何实现++操作呢？(分为以下几种情况)

假设当前迭代器"指向"cur位置，cur的父结点为parent。

1、cur的右子树存在

++后，只需找到右子树的最左结点即可。

2、cur的右子树为空

(1)cur是parent的左孩子

直接返回parent。(此时parent就是我们需要找的结点)

(2)cur是parent的右孩子

说明以parent为根的子树已经遍历完了，接下来让cur=parent，parent=cur->_parent，然后在做判断。最坏情况下，cur = _root，parent=nullptr，这时直接返回parent即可，我们这里让结束位置为nullptr。

代码实现：

Self& operator++(){Node* cur = _node;Node* parent = cur->_parent;if (cur->_right)  //右子树不为空，找右子树的最左结点{cur = cur->_right;while (cur->_left)cur = cur->_left;_node = cur;}else{while (parent && parent->_right == cur){cur = parent;parent = cur->_parent;}//直到cur是parent的左，那么parent就是我们的目标   //极端情况下，parent走到nullptr，这说明整棵树已经访问完了，直接返回nullptr(parent)_node = parent;}return  *this;}

那么如何实现--操作呢？(分为以下几种情况) 

迭代器--的实现跟++的思路完全类似，逻辑正好反过来即可，因为它访问顺序是右子树->根结点->
左子树。

假设当前迭代器"指向"cur位置，cur的父结点为parent。

1、cur的左子树存在

--后，只需找到左子树的最右结点即可。

2、cur的左子树为空

(1)cur是parent的右孩子

直接返回parent。(此时parent就是我们需要找的结点)

(2)cur是parent的左孩子

说明以parent为根的子树已经遍历完了，接下来让cur=parent，parent=cur->_parent，然后在做判断。

代码实现：

Self& operator--(){Node* cur = _node;Node* parent = cur->_parent;if (cur->_left) //左子树不为空，找左子树的最右结点{cur = cur->_left;while (cur->_right)cur = cur->_right;_node = cur;}else{while (parent && parent->_left == cur){cur = parent;parent = cur->_parent;}//直到cur是parent的右，那么parent就是我们的目标   _node = parent;}return *this;}

完成这一步，我们迭代器的封装任务差不多已经完成了，接下来我们需要在红黑树中实现Begin和End：

public:typedef RBTreeIterator<T, T&, T*> Iterator;  //普通迭代器typedef RBTreeIterator<T, const T&,const T*> ConstIterator; //const迭代器Iterator Begin(){Node* cur = _root;while (cur->_left)cur = cur->_left;return Iterator(cur);}Iterator End(){return Iterator(nullptr);  //我们这里让nullptr当最终结点}ConstIterator Begin() const{Node* cur = _root;while (cur->_left)cur = cur->_left;return ConstIterator(cur);}ConstIterator End() const{return ConstIterator(nullptr);}

在set中：

public:typedef typename RBTree<K, K, KeyOfSet>::Iterator iterator;typedef typename RBTree<K, K, KeyOfSet>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}

在map中：

public:typedef typename RBTree<K, pair<K, V>, KeyOfMap>::Iterator iterator;typedef typename RBTree<K, pair<K, V>, KeyOfMap>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}

 我们大致的任务已经完成了，接下来我们来写一段代码验证一下(看看是否会出现错误)：

//Test.cpp
#include "MyMap.h"
#include "MySet.h"void TestSet()
{blue::set<int> s;s.insert(5);s.insert(1);s.insert(3);s.insert(2);s.insert(6);blue::set<int>::iterator sit = s.begin();while (sit != s.end()){cout << *sit << " ";++sit;}cout << endl;
}void TestMap()
{blue::map<string, string> dict;dict.insert({ "sort", "排序" });dict.insert({ "left", "左边" });dict.insert({ "right", "右边" });blue::map<string, string>::iterator it = dict.begin();while (it != dict.end()){cout << it->first << ":" << it->second << endl;++it;}cout << endl;
}int main()
{TestSet();cout << "-----------------------" << endl;TestMap();return 0;
}

运行结果：

运行结果暂时没有什么问题。

这里有一个bug，看下面测试代码：

void Print(const blue::set<int>& s)
{bit::set<int>::const_iterator it = s.end();while (it != s.begin()){--it;cout << *it << " ";}cout << endl;
}

我们上面将end()指向nullptr，那么如果逆向遍历，--it就会出现错误，所以我们在--it时先判断一下，如果指向空，那么就修改_node为红黑树的最后一个结点，那么，问题又来了，怎么获得最后一个结点呢？所以我们需要知道红黑树的头结点，所以，我们在RBTreeIterator这个类中还需要一个成员变量来记录根节点：

修改operator--如下：

Self& operator--() {if (_node == nullptr){Node* cur = _root;while (cur->_right)cur = cur->_right;_node = cur;return *this;}Node* cur = _node;Node* parent = cur->_parent;if (cur->_left) //左子树不为空，找左子树的最右结点{cur = cur->_left;while (cur->_right)cur = cur->_right;_node = cur;}else{while (parent && parent->_left == cur){cur = parent;parent = cur->_parent;}//直到cur是parent的右，那么parent就是我们的目标   _node = parent;}return *this;}

解决完上述问题，还有一个问题，set和map中的K的值是不允许修改的，因为若修改就可能会破坏红黑树的结构，但我们写的代码中通过普通迭代器是能够修改的，如果要解决可以这样修改：

在set中：

在map中：

五、[]

好了，好了，到这里我们将上面的坑都踩完了，接下来最后最后一个功能，也是比较重要的，就是处理map中[]的实现逻辑：

map中的[]的逻辑其实就是利用了insert接口。

我们在红黑树中实现Insert的返回值是bool，接下来我们将它改为pair<Iterator,bool>类型：

pair<Iterator,bool> Insert(const T& data)
{if (_root == nullptr){_root = new Node(data);_root->_col = BLACK;//return true;return { Iterator(_root, _root),true };}Node* parent = nullptr;Node* cur = _root;KeyOfT kot;while (cur){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;return { Iterator(cur, _root),false };}cur = new Node(data);Node* newnode = cur;cur->_col = RED; if (kot(parent->_data) < kot(data))parent->_right = cur;elseparent->_left = cur;cur->_parent = parent;while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK; grandfather->_col = RED;}else {RotateL(parent);RotateR(grandfather);cur->_col = BLACK;  grandfather->_col = RED;}break; }}else  {Node* uncle = grandfather->_left;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_right){RotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else {RotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}}_root->_col = BLACK;//return true;return { Iterator(newnode, _root),true };
}

完成对Insert的调整后，在set和map的insert也要跟着调：

在set中：

在map中：

接下来，我们就着手实现[]，在map中：

V& operator[](const K& key)
{pair<iterator, bool> ret = _t.Insert({ key,V() });return (ret.first)->second;
}

是不是非常简单！ 

六、其他问题

1、构造函数

RBTree() = default;

2、拷贝构造

RBTree(const RBTree<K, T, KeyOfT>& t)
{_root = Copy(t._root);
}Node* Copy(Node* root)
{if (root == nullptr)return nullptr;Node* newnode = new Node(root->_data);newnode->_left = Copy(root->_left);newnode->_right = Copy(root->_right);return newnode;
}

3、赋值重载

RBTree& operator=(RBTree tmp)
{swap(tmp._root);return *this;
}

4、析构函数

~RBTree()
{Destroy(_root);_root = nullptr;
}void Destroy(Node* root)
{if (root == nullptr)return;Destroy(root->_left);Destroy(root->_right);delete root;
}

七、源码 

(1)RBTree.h

#pragma once
#include <iostream>
using namespace std;enum Colour
{RED,BLACK
};template<class T>
struct RBTreeNode
{T _data;RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;	Colour _col;RBTreeNode(const T& data):_data(data), _left(nullptr), _right(nullptr), _parent(nullptr){}
};//Ref和Ptr是为了兼容普通迭代器和const迭代器
template<class T,class Ref,class Ptr>
struct RBTreeIterator
{typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, Ref, Ptr> Self;Node* _node; //当前结点指针Node* _root; //记录红黑树的根结点RBTreeIterator(Node* node,Node* root):_node(node),_root(root){}Self& operator++() {Node* cur = _node;Node* parent = cur->_parent;if (cur->_right)   //右子树不为空，找右子树的最左结点{cur = cur->_right;while (cur->_left)cur = cur->_left;_node = cur;}else{while (parent && parent->_right == cur){cur = parent;parent = cur->_parent;}//直到cur是parent的左，那么parent就是我们的目标   //极端情况下，parent走到nullptr，这说明整棵树已经访问完了，直接返回nullptr(parent) _node = parent;}return  *this;}Self& operator--() {if (_node == nullptr){Node* cur = _root;while (cur->_right)cur = cur->_right;_node = cur;return *this;}Node* cur = _node;Node* parent = cur->_parent;if (cur->_left) //左子树不为空，找左子树的最右结点{cur = cur->_left;while (cur->_right)cur = cur->_right;_node = cur;}else{while (parent && parent->_left == cur){cur = parent;parent = cur->_parent;}//直到cur是parent的右，那么parent就是我们的目标   _node = parent;}return *this;}Ref operator*() const{return _node->_data;}Ptr operator->() const{return &(_node->_data);}bool operator==(const Self& s) const{return _node == s._node;}bool operator!=(const Self& s) const{return _node != s._node;}
};template<class K,class T,class KeyOfT>
class RBTree
{
public:RBTree() = default;RBTree(const RBTree<K, T, KeyOfT>& t){_root = Copy(t._root);}RBTree& operator=(RBTree tmp){swap(tmp._root);return *this;}~RBTree(){Destroy(_root);_root = nullptr;}public:typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, T&, T*> Iterator;typedef RBTreeIterator<T, const T&,const T*> ConstIterator;Iterator Begin(){Node* cur = _root;while (cur->_left)cur = cur->_left;return Iterator(cur,_root);}Iterator End(){return Iterator(nullptr,_root);}ConstIterator Begin() const{Node* cur = _root;while (cur->_left)cur = cur->_left;return ConstIterator(cur,_root);}ConstIterator End() const{return ConstIterator(nullptr,_root);}public:pair<Iterator,bool> Insert(const T& data){if (_root == nullptr){_root = new Node(data);_root->_col = BLACK;//return true;return { Iterator(_root,_root),true };}Node* parent = nullptr;Node* cur = _root;KeyOfT kot;while (cur){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;return { Iterator(cur,_root),false };}cur = new Node(data);Node* newnode = cur;cur->_col = RED; if (kot(parent->_data) < kot(data))parent->_right = cur;elseparent->_left = cur;cur->_parent = parent;while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK; grandfather->_col = RED;}else {RotateL(parent);RotateR(grandfather);cur->_col = BLACK;  grandfather->_col = RED;}break; }}else  {Node* uncle = grandfather->_left;if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else{if (cur == parent->_right){RotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else {RotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}}_root->_col = BLACK;//return true;return { Iterator(newnode,_root),true };}private:void RotateR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR)subLR->_parent = parent;Node* pParent = parent->_parent;subL->_right = parent;parent->_parent = subL;if (parent == _root){_root = subL;subL->_parent = nullptr;}else{if (pParent->_left == parent)pParent->_left = subL;elsepParent->_right = subL;subL->_parent = pParent;}}void RotateL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;parent->_right = subRL;if (subRL)subRL->_parent = parent;Node* parentParent = parent->_parent;subR->_left = parent;parent->_parent = subR;if (parentParent == nullptr){_root = subR;subR->_parent = nullptr;}else{if (parent == parentParent->_left)parentParent->_left = subR;elseparentParent->_right = subR;subR->_parent = parentParent;}}Node* Copy(Node* root){if (root == nullptr)return nullptr;Node* newnode = new Node(root->_data);newnode->_left = Copy(root->_left);newnode->_right = Copy(root->_right);return newnode;}void Destroy(Node* root){if (root == nullptr)return;Destroy(root->_left);Destroy(root->_right);delete root;}
private:Node* _root = nullptr; 
};

(2)MySet.h 

#pragma once
#include "RBTree.h"
namespace blue
{template<class K>class set{struct KeyOfSet{const K& operator()(const K& key){return key;}};public:typedef typename RBTree<K, const K, KeyOfSet>::Iterator iterator;typedef typename RBTree<K, const K, KeyOfSet>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}public:pair<iterator,bool> insert(const K& key){return _t.Insert(key);}private:RBTree<K, const K, KeyOfSet> _t;};
}

(3)MyMap.h 

#pragma once
#include "RBTree.h"
namespace blue
{template<class K,class V>class map{struct KeyOfMap{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename RBTree<K, pair<const K, V>, KeyOfMap>::Iterator iterator;typedef typename RBTree<K, pair<const K, V>, KeyOfMap>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}public:pair<iterator,bool> insert(const pair<K, V>& kv){return _t.Insert(kv);}V& operator[](const K& key){pair<iterator, bool> ret = _t.Insert({ key,V() });return (ret.first)->second;}private:RBTree<K, pair<const K, V>, KeyOfMap> _t;};
}

(4)Test.cpp 

#define _CRT_SECURE_NO_WARNINGS 1#include "MyMap.h"
#include "MySet.h"void Print(const blue::set<int>& s)
{blue::set<int>::const_iterator it = s.end();while (it != s.begin()){--it;cout << *it << " ";}cout << endl;
}void TestSet()
{blue::set<int> s;s.insert(5);s.insert(1);s.insert(3);s.insert(2);s.insert(6);blue::set<int>::iterator sit = s.begin();//*sit += 10;while (sit != s.end()){cout << *sit << " ";++sit;}cout << endl;Print(s);}void TestMap()
{blue::map<string, string> dict;dict.insert({ "sort", "排序" });dict.insert({ "left", "左边" });dict.insert({ "right", "右边" });dict["left"] = "左边，剩余";dict["insert"] = "插入";dict["string"];blue::map<string, string>::iterator it = dict.begin();while (it != dict.end()){// 不能修改first，可以修改second//it->first += 'x';it->second += 'x';cout << it->first << ":" << it->second << endl;++it;}cout << endl;
}int main()
{TestSet();cout << "-----------------------" << endl;TestMap();return 0;
}

八、总结

本篇内容到这里就结束啦，主要讲了如何用红黑树来封装set和map容器，希望对大家有帮助，祝生活愉快！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/60572.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

4399 C++面试题及参考答案

4399 C++面试题及参考答案

C 和 C++ 的区别是什么？ C 语言是一种过程式编程语言，而 C++ 是在 C 语言基础上发展而来的面向对象编程语言。 从语法层面来看，C 语言没有类和对象的概念。 而在 C++ 中可以定义类，把数据和操作数据的函数封装在一起，像这样： class Point { public:int x;int y;Point(int…
阅读更多...
类与实例

类与实例

1 问题如何理解类与实例&#xff1f; 2 方法 类与实例 类(class)的概述&#xff1a;用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 类是一类事物&#xff0c;实例是具体的一个事物。 编程与生活是相通的&#xff0…
阅读更多...
kafka常见面试题总结

kafka常见面试题总结

Kafka 核心知识解析 一、Kafka 消息发送流程 Kafka 发送消息涉及两个线程&#xff1a;main 线程和 sender 线程。在 main 线程中&#xff0c;会创建一个双端队列 RecordAccumulator&#xff0c;main 线程负责将消息发送给 RecordAccumulator&#xff0c;而 sender 线程则从 R…
阅读更多...
Rust 所有权机制

Rust 所有权机制

Rust 所有权机制 本文示例代码地址 所有权是Rust中最独特的特性&#xff0c;它让Rust无需GC就可以保证内存安全。 什么是所有权&#xff1f; 所有权&#xff08;ownership&#xff09;是 Rust 用于如何管理内存的一组规则。所有程序都必须管理其运行时使用计算机内存的方式…
阅读更多...
2024/11/4 计网强化

2024/11/4 计网强化

10: 17: 22: 09: 11: 12: 13&#xff1a; 14&#xff1a; 15&#xff1a; 18&#xff1a; 19&#xff1a; 20: 21: 16:
阅读更多...
hutool-雪花算法 id 生成器

hutool-雪花算法 id 生成器

配置 workId 和 datacenterId 设置工作机器ID&#xff08;workerId&#xff09;和数据中心ID&#xff08;datacenterId&#xff09;&#xff0c;这两个参数用于确保在分布式环境中生成的ID是唯一的。使用配置 yaml 文件的方式获取&#xff0c;配置方式参考&#xff1a;https:/…
阅读更多...
CentOS 9 配置网卡

CentOS 9 配置网卡

在 CentOS 9 中配置网卡&#xff0c;通常涉及以下几个步骤&#xff1a; 1. 查看网络接口 首先&#xff0c;确认系统上存在的网络接口。可以使用 ip 命令或 ifconfig 命令查看网络接口的状态。 ip a 或者&#xff1a; ifconfig 这将列出所有可用的网络接口&#xff08;例如…
阅读更多...
力扣104 ： 二叉树最大深度

力扣104 ： 二叉树最大深度

补&#xff1a;二叉树的最大深度 描述&#xff1a; 给定一个二叉树 root &#xff0c;返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 何解&#xff1f; 树一般常用递归&#xff1a;递到叶子节点开始倒着处理
阅读更多...
机器情绪及抑郁症算法

机器情绪及抑郁症算法

&#x1f3e1;作者主页&#xff1a;点击&#xff01; &#x1f916;编程探索专栏&#xff1a;点击&#xff01; ⏰️创作时间&#xff1a;2024年11月12日17点02分 点击开启你的论文编程之旅https://www.aspiringcode.com/content?id17230869054974 计算机来理解你的情绪&a…
阅读更多...
M4 lotus 源码编译安装

M4 lotus 源码编译安装

查看系统版本 sw_vers ProductName: macOS ProductVersion: 15.1安装依赖 xcode-select -p /Library/Developer/CommandLineToolsbrew install go jq pkg-config hwloc coreutilscurl --proto https --tlsv1.2 -sSf https://sh.rustup.rs | sh设置环境变量 export LIBRARY…
阅读更多...
JAVA学习日记（十五） 数据结构

JAVA学习日记（十五） 数据结构

一、数据结构概述 数据结构是计算机底层存储、组织数据的方式。 数据结构是指数据相互之间以什么方式排列在一起的。 数据结构是为了更加方便的管理和使用数据&#xff0c;需要结合具体的业务场景来进行选择。 二、常见的数据结构 &#xff08;一&#xff09;栈 特点&…
阅读更多...
i春秋-SQLi（无逗号sql注入，-- -注释）

i春秋-SQLi（无逗号sql注入，-- -注释）

练习平台地址 竞赛中心 题目描述 后台有获取flag的线索应该是让我们检查源码找到后台 题目内容 空白一片 F12检查源码 发现login.php 访问login.php?id1 F12没有提示尝试sql注入 常规sql注入 //联合注入得到表格列数 1 order by 3 # 1 union select 1,2,3 #&#xff08…
阅读更多...
sql注入之二次注入（sqlilabs-less24）

sql注入之二次注入（sqlilabs-less24）

二阶注入&#xff08;Second-Order Injection&#xff09;是一种特殊的 SQL 注入攻击&#xff0c;通常发生在用户输入的数据首先被存储在数据库中&#xff0c;然后在后续的操作中被使用时&#xff0c;触发了注入漏洞。与传统的 SQL 注入&#xff08;直接注入&#xff09;不同&a…
阅读更多...
nginx 部署2个相同的vue

nginx 部署2个相同的vue

起因&#xff1a; 最近遇到一个问题&#xff0c;在前端用nginx 部署 vue&#xff0c; 发现如果前端有改动&#xff0c;如果不适用热更新&#xff0c;而是直接复制项目过去&#xff0c;会404 因此想到用nginx 负载两套相同vue项目&#xff0c;然后一个个复制vue项目就可以了。…
阅读更多...
MySQL：CRUD

MySQL：CRUD

MySQL表的增删改查&#xff08;操作的是表中的记录&#xff09; CRUD(增删改查) C-Create新增R-Retrieve检查&#xff0c;查询U-Update更新D-Delete删除 新增&#xff08;Create&#xff09; 语法&#xff1a; 单行数据全列插入 insert into 表名[字段一&#xff0c;字段…
阅读更多...
centos7 node升级到node18

centos7 node升级到node18

使用jenkins发布vue3项目提示node18安装失败 错误日志&#xff1a; /var/lib/jenkins/tools/jenkins.plugins.nodejs.tools.NodeJSInstallation/Node18/bin/node: /lib64/libm.so.6: version GLIBC_2.27 not found (required by /var/lib/jenkins/tools/jenkins.plugins.node…
阅读更多...
万字长文解读深度学习——ViT、ViLT、DiT

万字长文解读深度学习——ViT、ViLT、DiT

文章目录 &#x1f33a;深度学习面试八股汇总&#x1f33a;ViT1. ViT的基本概念2. ViT的结构与工作流程1. 图像分块&#xff08;Image Patch Tokenization&#xff09;2. 位置编码&#xff08;Positional Encoding&#xff09;3. Transformer 编码器&#xff08;Transformer En…
阅读更多...
MFC中Excel的导入以及使用步骤

MFC中Excel的导入以及使用步骤

参考地址 在需要对EXCEL表进行操作的类中添加以下头文件&#xff1a;若出现大量错误将其放入stdafx.h中 #include "resource.h" // 主符号 #include "CWorkbook.h" //单个工作簿 #include "CRange.h" //区域类&#xff0c;对Excel大…
阅读更多...
前端开发中常用的包管理器（npm、yarn、pnpm、bower、parcel）

前端开发中常用的包管理器（npm、yarn、pnpm、bower、parcel）

文章目录 1. npm (Node Package Manager)2. Yarn (Yarn Package Manager)3. pnpm4. Bower5. Parcel总结 前端开发中常用的包管理器主要有以下几个&#xff1a; 1. npm (Node Package Manager) 简介&#xff1a; npm 是 Node.js 的默认包管理器&#xff0c;也是最广泛使用的包…
阅读更多...
Linux（CentOS）安装 Nginx

Linux（CentOS）安装 Nginx

CentOS版本&#xff1a;CentOS 7 Nginx版本&#xff1a;1.24.0 两种安装方式&#xff1a; 一、通过 yum 安装&#xff0c;最简单&#xff0c;一键安装&#xff0c;全程无忧。 二、通过编译源码包安装&#xff0c;需具备配置相关操作。 最后附&#xff1a;设置 Nginx 服务开…
阅读更多...
最新文章

Copyright @ 2022~2023