模拟实现map和set

• map和set是红黑树的两种不同封装形式，底层使用同一颗泛型结构的红黑树。
• set是红黑树的K模型；map是红黑树的KV模型。

下面的代码和讲解着重体现红黑树的底层实现和map\set上层封装的衔接。关于二叉搜索树性质，map和set的介绍，搜索树的旋转，红黑树的性质等内容请依次阅读下面几篇文章：

1. 【高阶数据结构】二叉搜索树 {概念；实现：核心结构，增删查，默认成员函数；应用：K模型和KV模型；性能分析；相关练习}
2. 【STL】map和set的介绍和使用 {关联式容器；键值对；map和set；multimap和multiset；OJ练习}
3. 【高阶数据结构】AVL树 {概念及实现；节点的定义；插入并调整平衡因子；旋转操作：左单旋，右单旋，左右双旋，右左双旋；AVL树的验证及性能分析}
4. 【高阶数据结构】红黑树 {概念及性质；红黑树节点的定义；红黑树插入操作详细解释；红黑树的验证}

---

一、红黑树的核心结构

• 问题一：map和set底层使用同一颗泛型结构的红黑树，如何处理map(pair<key,value>)和set(key)存储值不同的问题？

  解决方案：泛型底层红黑树的存储类型，通过不同的实例化参数，实现出map和set。

1.1 节点的定义

// RBTree.hpp
#pragma once
#include <utility>
#include <assert.h>
using std::pair;
using std::make_pair;enum Color{RED,BLACK
};template <class T>
struct RBTreeNode{typedef RBTreeNode<T> Node;Node *_left;Node *_right;Node *_parent;T _data; //泛型底层红黑树的存储类型，通过不同的实例化参数，实现出map和set。Color _color;RBTreeNode(const T &data = T(), Color color = RED):_left(nullptr),_right(nullptr),_parent(nullptr),_data(data),_color(color){}
};

---

1.2 红黑树的结构定义

STL中的红黑树结构

• 为了后续实现关联式容器map/set，STL红黑树的实现中增加一个头结点；
• 因为根节点必须为黑色，为了与根节点进行区分，将头结点给成红色；
• 并且让头结点的_parent域指向红黑树的根节点，_left域指向红黑树中最小的节点，_right域指向红黑树中最大的节点。

头结点的作用(begin, end)：

• STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？
• 能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行–操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置：

// RBTree.hpp
// K: key的类型，
// T: 如果是map，则为pair<K, V>; 如果是set，则为K
// KofT: 通过T类型的data来获取key的一个仿函数类
template <class K, class T, class KofT>
class RBTree{typedef RBTreeNode<T> Node; //第二个模版参数T，决定红黑树的存储类型Node *_phead; //指向头结点的指针public:typedef RBT_iterator<T, T&, T*> iterator; //普通迭代器typedef RBT_iterator<T, const T&, const T*> const_iterator; //const迭代器//构造，创建头结点RBTree(){_phead = new Node(T(), RED); //为了和根节点区分，头节点设为红色_phead->_left = _phead->_right = _phead;}//普通对象返回普通迭代器iterator begin(){return iterator(_phead->_left); //begin放在红黑树最左节点的位置}iterator end(){return iterator(_phead); //end放在头结点的位置} //const对象返回const迭代器const_iterator begin() const{ return const_iterator(_phead->_left); }const_iterator end() const{return const_iterator(_phead);}//插入和查找pair<iterator, bool> Insert(const T& data);iterator Find(const K &k);private://获取根节点，注意返回指针的引用便于修改Node*& GetRoot(){return _phead->_parent;}//获取最左节点Node* LeftMost(){Node *proot = GetRoot();if(proot == nullptr){return _phead;}else{Node *left = proot;while(left->_left != nullptr){left = left->_left;}return left;}}//获取最右节点Node* RightMost(){Node *proot = GetRoot();if(proot == nullptr){return _phead;}else{Node *right = proot;while(right->_right != nullptr){right = right->_right;}return right;}}//旋转void RotateL(Node *parent);void RotateR(Node *parent);

---

二、红黑树的迭代器

2.1 迭代器的基本操作

红黑树的迭代器底层封装一个指向节点的指针，基本操作的详细解释请参照list迭代器的实现。

// RBTree.hpp
template<class T, class Ref, class Ptr>
class RBT_iterator{typedef RBT_iterator<T, Ref, Ptr> iterator;typedef RBTreeNode<T> Node;Node *_pnode; //红黑树的迭代器底层封装一个指向节点的指针public://基本操作请参照list迭代器的实现，不做过多解释RBT_iterator(Node *pnode):_pnode(pnode){}Ref operator*() const{ return _pnode->_data;}Ptr operator->() const{return &_pnode->_data;}bool operator==(const iterator &it) const{return _pnode == it._pnode;}bool operator!=(const iterator &it) const{return _pnode != it._pnode;}//......
};

---

2.2 operator++

红黑树迭代器的实现难点在于++和–操作：

operator++：（中序：左子树，根，右子树）

1. 如果当前节点的右子树不为空，++就是找右子树中序的第一个节点（最左节点）。11->12。

2. 如果当前节点的右子树为空，++就是找孩子不是右节点的那个祖先。7->8。

3. 特殊情况：根节点没有右孩子，迭代器在根位置（如下图），此时进行++迭代器因该指向头结点end遍历结束。但如果按照上面的逻辑由于根节点恰好是头结点的右孩子（根节点没有右孩子），最终迭代器又会指向根节点永远无法到达头结点end，导致程序陷入死循环。因此需要特殊处理。

提示：右子树为空或孩子是右节点，说明这棵子树已经遍历访问完了。

  //前置和后置++，后置复用前置iterator& operator++(){if(_pnode->_right != nullptr) //如果右子树不为空，++就是找右子树的最左节点{Node *left = _pnode->_right; while(left->_left != nullptr){left = left->_left;}_pnode = left;}else //如果右子树为空，++就是找孩子不是右节点的那个祖先{Node *parent = _pnode->_parent;while(_pnode == parent->_right){_pnode = parent;parent = parent->_parent;}//特殊情况：根节点没有右孩子，迭代器在根位置。//经过循环此时_pnode指向头节点，parent指向根节点，做特殊处理使_pnode指向头结点if(_pnode->_right != parent)_pnode = parent;}return *this;}iterator operator++(int){iterator it(_pnode);++*this;return it;}

---

2.3 operator–

operator–：和++相反（右子树，根，左子树）

1. 如果当前节点的左子树不为空，–就是找左子树的最右节点。8->7
2. 如果当前节点的左子树为空，–就是找孩子不是左节点的那个祖先。12->11
3. 特殊情况：如果迭代器指向end，即头结点。此时进行–操作因该使迭代器指向最右节点。
4. –操作也存在++操作中的特殊情况——根节点没有左孩子。但不需要做特殊处理，–后仍指向根节点即可。

提示：左子树为空或孩子是左节点，说明这棵子树已经遍历访问完了。

  //前置和后置--，后置复用前置iterator operator--(){//特殊情况：如果迭代器指向end，进行--操作因该使迭代器指向最右节点。if(_pnode->_parent->_parent == _pnode && _pnode->_color == RED){_pnode = _pnode->_right;}else if(_pnode->_left != nullptr) //如果左子树不为空，--就是找左子树的最右节点{Node *right = _pnode->_left;while(right->_right != nullptr){right = right->_right;}_pnode = right;}else //如果左子树为空，--就是找孩子不是左节点的那个祖先{Node *parent = _pnode->_parent;while(_pnode == parent->_left){_pnode = parent;parent = parent->_parent;}_pnode = parent; //不需要特殊处理}return *this;}iterator operator--(int){iterator it(_pnode);--*this;return it;}

---

三、红黑树的插入和查找

• 问题二：在进行查找、插入、删除等操作时，要对key值进行比较。在同一模版中，如何区别比较map和set中的key值？

  解决方案：通过传入仿函数KofT(KeyofTree)解决。如果是set，传入SetKofT返回data的值；如果是map，传入MapKofT返回data.first的值；

  注意：pair中重载了关系运算符，但first和second都参与运算，不符合要求。要求只比较pair.first (key)。

3.1 插入

pair<iterator, bool> Insert(const T& data){Node* &rproot = GetRoot(); //这里注意要用引用接收返回值if(rproot == nullptr){rproot = new Node(data, BLACK); //因为GetRoot返回指针的引用，所以改的实际是_phead->_parentrproot->_parent = _phead;_phead->_left = _phead->_right = rproot;//返回pair<iterator, bool>，方便实现operator[]。return make_pair(iterator(rproot), true); }KofT kot; //创建KofT对象，用于取出data中的keyNode *cur = rproot;Node *parent = nullptr;while(cur != nullptr){parent = cur;if(kot(data) > kot(cur->_data)) //不管是map还是set都能正确的取出key进行比较。cur = cur->_right;else if(kot(data) < kot(cur->_data))cur = cur->_left;elsereturn make_pair(iterator(cur), false);}cur = new Node(data, RED);if(kot(data) > kot(parent->_data)){parent->_right = cur;}else{parent->_left = cur;}cur->_parent = parent;Node* newnode = cur; //在调整红黑树的过程中cur的指向会改变，所以要提前记录新节点的指针。//上一次循环中grandparent 为根节点，此次循环parent == _phead//关于红黑树性质的检查和平衡调整请阅读文章：【高阶数据结构】红黑树while(parent != _phead && parent->_color == RED){Node* grandparent = parent->_parent;assert(grandparent!=nullptr);assert(grandparent->_color == BLACK);Node* uncle = grandparent->_left;if(grandparent->_left == parent)uncle = grandparent->_right;if(uncle != nullptr && uncle->_color == RED){parent->_color = uncle->_color = BLACK;grandparent->_color = RED;cur = grandparent;parent = grandparent->_parent;}else{if(parent == grandparent->_left){if(cur == parent->_left){RotateR(grandparent);parent->_color = BLACK;grandparent->_color = RED;}else{RotateL(parent);RotateR(grandparent);cur->_color = BLACK;grandparent->_color = RED;}}else{if(cur == parent->_right){RotateL(grandparent);parent->_color = BLACK;grandparent->_color = RED;}else{RotateR(parent);RotateL(grandparent);cur->_color = BLACK;grandparent->_color = RED;}}break;}} //end of while//如果在调整过程中将根节点变为红色，记得重新变回黑色。if(parent == _phead)cur->_color = BLACK;//令头节点的左指针指向红黑树的最左节点_phead->_left = LeftMost();//令头节点的右指针指向红黑树的最右节点_phead->_right = RightMost();//返回pair<iterator, bool>，方便实现operator[]。return make_pair(iterator(newnode), true);}

---

3.2 旋转

  void RotateL(Node *parent){Node* subR = parent->_right;Node* subRL = subR->_left;Node* ppNode = parent->_parent;subR->_left = parent;parent->_parent = subR;parent->_right = subRL;if(subRL != nullptr)subRL->_parent = parent;if(ppNode == _phead) //如果parent是根节点，要修改头结点的_parent指针。{_phead->_parent = subR;}else{if(parent == ppNode->_left)ppNode->_left = subR; elseppNode->_right = subR;}subR->_parent = ppNode;}void RotateR(Node *parent){Node *subL = parent->_left;Node *subLR = subL->_right;Node *ppNode = parent->_parent;subL->_right = parent;parent->_parent = subL;parent->_left = subLR;if(subLR != nullptr)subLR->_parent = parent;if(ppNode == _phead) //如果parent是根节点，要修改头结点的_parent指针。{_phead->_parent = subL;}else{if(parent == ppNode->_left)ppNode->_left = subL;elseppNode->_right = subL;}subL->_parent = ppNode;}

---

3.3 查找

  iterator Find(const K &k){KofT kot; //创建KofT对象，用于取出data中的keyNode *cur = GetRoot();if(cur == nullptr) return end(); //如果是空树，返回end。while(cur != nullptr){if(k > kot(cur->_data)) //不管是map还是set都能正确的取出key进行比较。cur = cur->_right;else if(k < kot(cur->_data))cur = cur->_left;elsereturn iterator(cur); //找到返回指向节点的迭代器}return end(); //如果找不到，返回end。}

---

四、map和set的封装

4.1 map

//Map.hpp
#pragma once
#include "RBTree.hpp"namespace zty{template <class K, class V>class map{//MapKofT返回kv.firststruct MapKofT{const K& operator()(const pair<K,V> &kv){return kv.first;}};//map是KV模型的红黑树，存储pair<K,V>键值对typedef RBTree<K, pair<K,V>, MapKofT> RBT;RBT _rbt;public://取类模版中的内嵌类型时，需要在类型前加typename；告诉编译器，后面这一串是类型不是静态成员。typedef typename RBT::iterator iterator; //map的迭代器类型typedef typename RBT::const_iterator const_iterator; //const迭代器//C++11的用法：使用了default关键字，表示使用编译器自动生成的默认构造函数map() = default;//迭代器区间构造    template <class InputIterator>map(InputIterator first, InputIterator last){while(first!=last){_rbt.Insert(*first);++first;}}iterator begin(){return _rbt.begin();}iterator end(){return _rbt.end();}const_iterator begin() const{return _rbt.begin();}const_iterator end() const{return _rbt.end();}std::pair<iterator, bool> insert(const pair<K,V> &kv){return _rbt.Insert(kv);}//Insert返回pair<iterator, bool>，方便实现operator[]。//具体内容阅读文章：【STL】map和set的介绍和使用 V& operator[](const K& k){pair<iterator, bool> ret = _rbt.Insert(make_pair(k, V()));return ret.first->second;}iterator find(const K& k){return _rbt.Find(k);}};
}

---

4.2 set

//Set.hpp
#pragma once
#include "RBTree.hpp"namespace zty{
template <class K>class set{//SetKofT返回kstruct SetKofT{const K& operator()(const K &k){return k;}};//set是K模型的红黑树，只存储key值typedef RBTree<K, K, SetKofT> RBT;RBT _rbt;public://取类模版中的内嵌类型时，需要在类型前加typename；告诉编译器，后面这一串是类型不是静态成员。typedef typename RBT::iterator iterator; //set的迭代器类型typedef typename RBT::const_iterator const_iterator; //const迭代器//C++11的用法：使用了default关键字，表示使用编译器自动生成的默认构造函数set() = default;//迭代器区间构造template <class InputIterator>set(InputIterator first, InputIterator last){while(first!=last){_rbt.Insert(*first);++first;}}iterator begin(){return _rbt.begin();} iterator end(){return _rbt.end();}const_iterator begin() const{return _rbt.begin();}const_iterator end() const{return _rbt.end();}std::pair<iterator, bool> insert(const K& k){return _rbt.insert(k);}iterator find(const K& k){return _rbt.Find(k);}};
}