C++进阶学习：map和set的实现

我们知道set和map的底层其实是红黑树，在学习完红黑树这个数据结构之后，我们开始简单模拟实现一下这两个STL容器

1.set和map的泛型编程思想

2.红黑树的结构

2.1.迭代器的实现

2.2.迭代器的 operator++

2.3.迭代器的代码

2.4.set和map迭代器

2.4.1.Insert的代码

2.4.2迭代器结构

3.代码实现

3.1. set.h

3.2. map.h

3.3. RBTree.h

1.set和map的泛型编程思想

因为set和map底层高度封装所以我们需要通过源码的阅读来确定大致框架，我们发现map和set的内部均有一个value_type类型，其可以是key也可以是pair<>简化一下上图，我们大致定义出set和map

我们知道泛型编程的核心就是代码的复用，在这一章节体现在同一个RBTree.h文件可以支持mySet.h和myMap.h随时用

而我们在前面红黑树的学习过程中，对于insert的插入位置查找，以及find的数据位置查找都需要遍历树的分支，通过的是key来寻找，如果是set类型就直接寻找，但是如果是pair类型呢？我们可能会说那就是pair<>.first来实现就好了！这个回答是没有问题的，结果却是形成了两棵树或者是需要重载两个insert，一个为bool insert(const K& key)，另一个为bool insert(const pair<K, V>& kv) ，这样无法较好泛型编程思想

2.红黑树的结构

通过上部分的泛型编程，讲述我们在红黑树的中定义了一个新的变量KeyOfValue来实现这个对应set与map的匹配，又因为在C++学习进阶：set 和 map-CSDN博客中关于【】重载部分，我们知道了insert返回的是pair<iterator, bool>类型，所以我们开始定义迭代器！

2.1.迭代器的实现

首先迭代器是一个类似于指针的容器（本质是指针），内部存放节点，那么底层实现也是通过树的节点，并且为了实现const_iterator，需要传入多个模版参数，因为之前我们在list章节，讲过迭代器的实现这里的话就不赘述了，就大概展示一下结构组分

2.2.迭代器的 operator++

++和--这两个操作符重载均是为了通过迭代器进行节点的遍历，而根据红黑树的规律，以及STL库中set和map迭代器遍历规律，我们需要将节点通过正向or负向中序遍历的方式来实现！

2.3.迭代器的代码

template<class V, class Ref, class Ptr>
struct Tree_iterator
{typedef Tree_iterator<V, Ref, Ptr> Self;typedef RBTreeNode<V> Node;Node* _node = nullptr;Tree_iterator(Node* node):_node(node){}// 实现const的拷贝构造Tree_iterator(const Tree_iterator<V, V&, V*>& it):_node(it._node){}Self& operator=(const Self& s){_node = s._node;return *this;}Self& operator++(){// 右子树不为空，遍历到最左节点if (_node->_right != nullptr){Node* current = _node->_right;while (current != nullptr && current->_left != nullptr)current = current->_left;_node = current;}// 右子树为空 大的节点在祖先处else{Node* current = _node;Node* parent = current->_parent;// 如果current在parent的右进入循环，下一个节点就是祖父节点while (parent != nullptr && current == parent->_right){current = parent;parent = parent->_parent;}// 如果current是parent的左，不进入循环，下一个节点就是父亲节点_node = parent;}return *this;}Self& operator--(){if (_node->_left != nullptr){Node* current = _node->_left;while (current != nullptr && current->_right != nullptr)current = current->_right;_node = current;}else{Node* current = _node;Node* parent = current->_parent;while (parent != nullptr && current == parent->_left){current = parent;parent = parent->_parent;}_node = parent;}return *this;}bool operator!=(const Self& s) { return _node != s._node; }bool operator==(const Self& s) { return _node == s._node; }Ref operator*() { return _node->_value; }Ptr operator->() { return &_node->_value; }
};

2.4.set和map迭代器

实现完红黑树迭代器后我们开始实现set和map的迭代器，我们知道红黑树需要同时兼容set和map，而set是key类型并且key不能修改，map是pair<const Key, value>类型，这两个在实现时，set的迭代器不支持修改，而map的迭代器不支持key修改但是支持Value修改

2.4.1.Insert的代码

// 增查pair<iterator, bool> insert(const V& value){// 1.先插入节点if (_root == nullptr){_root = new Node(value);// 根节点默认为黑色_root->_col = BLACK;return make_pair(iterator(_root), true);}Node* parent = nullptr;Node* current = _root;while (current != nullptr){parent = current;if (kov(current->_value) < kov(value))current = current->_right;else if (kov(current->_value) > kov(value))current = current->_left;elsereturn make_pair(iterator(current), false);}Node* newNode = new Node(value);current = newNode;// 新增节点默认为红色current->_col = RED;// 通过大小插入左右if (kov(parent->_value) < kov(value))parent->_right = current;elseparent->_left = current;current->_parent = parent;// 2.实现颜色的变换  情况来回的迭代直至不满足循环 退出时就满足了红黑树while (parent != nullptr && parent->_col == RED){/*进入循环情况：同时满足父节点不为空，且为红色原因： 如果父节点为空，则current为_root如果父节点为黑色，就不用更新颜色了*/Node* grandparent = parent->_parent;// 找到叔叔节点位置if (parent == grandparent->_left){// uncle在父亲右边Node* uncle = grandparent->_right;// 情况一：叔叔存在，且叔叔为红色if (uncle != nullptr && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandparent->_col = RED;// 继续向上调整current = grandparent;parent = current->_parent;}// 情况二：叔叔不存在 或者 叔叔存在但是颜色为黑色else{if (current == parent->_left){RotateR(grandparent);parent->_col = BLACK;grandparent->_col = RED;}// current在右边else{RotateL(parent);RotateR(grandparent);// 通过旋转后，旋转内部就已经完成了指针的指向current->_col = BLACK;grandparent->_col = RED;}// 直接退出循环即可，也可以不退出，因为父亲已经为黑色了break;}}else{// uncle在父亲左边Node* uncle = grandparent->_left;if (uncle != nullptr && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandparent->_col = RED;// 继续向上调整current = grandparent;parent = current->_parent;}else{if (current == parent->_right){RotateL(grandparent);parent->_col = BLACK;grandparent->_col = RED;}// current在左边else {// 注意这里单旋的节点不同RotateR(parent);RotateL(grandparent);grandparent->_col = RED;current->_col = BLACK;}break;}}}// 保持根节点始终为黑色，当current到达根节点可能为RED，这里就在外部变黑_root->_col = BLACK;return make_pair(iterator(newNode), true);}

所以我们实现set和map时也需要按照这个规律，这里我们以set为例子，结合insert为pair<iterator, bool>类型的函数

2.4.2迭代器结构

set的迭代器结构

这样子我们应该是实现了const_iterator的作用，那我们通过插入数据来判断一下，插入是成功的，不过最终会出现报错

如下图所示

那如何解决呢？

法一：

我们知道这里是，普通类型的迭代器不能作为const_iterator的接收值，也就是类型无法匹配，那么我们可以通过类型的拷贝构造，将const_iterator可以转化为原生的iterator迭代器，这样子iterator既可以作为普通的迭代器，也可以实现为const_iterator，带着这样的想法我们实现一个拷贝构造函数，代码在2.3.处有样例

法二：

另外，我们在研究pair类型时，发现pair也通过法一类似的方法实现了一个拷贝构造函数，也就是我们可以通过其他类型来实现const_iterator，我们知道迭代器的本质就是一个节点的指针，那么Node* 转化为const_iterator理论上是可行的，在通过iterator的( )默认构造函数，就可以通过iterator(pointer)

有了set的迭代器为例子，以及insert的实现，我们现在开始实现map的迭代器，map和set主要不同就是，map支持普通迭代器修改，但是会限制key的修改，也就是我们不能像set一样锁死map

map的迭代器

我们在测试用例中尝试修改key，发现会出错，而value不受影响

3.代码实现

3.1. set.h

#pragma once
#include<iostream>
#include "RBTree.h"
using namespace std;namespace zhong
{// set的实现template<class V>class set{// 类型匹配 对应树的 class keyOfValuestruct SetKetOf{const V& operator()(const V& value_type) { return value_type; }	// 通过定义keyOfValue kov 然后 借助()重载 来 找到key};public:// 这里体现了typename的作用// 对类模板取内嵌类型，需要加typename告知编译器这里是内嵌类型typedef typename RBTree<V, V, SetKetOf>::const_iterator iterator;typedef typename RBTree<V, V, SetKetOf>::const_iterator const_iterator;// 迭代器iterator begin() const { return _tree.begin(); }iterator end() const { return _tree.end(); }// 增查pair<iterator, bool> insert(const V& value) { return _tree.insert(value); }// iterator find(const V& value) { return _tree.find(value); }private:RBTree<V, V, SetKetOf> _tree;};void test_set1(){set<int> s1;s1.insert(2);s1.insert(3);s1.insert(4);s1.insert(1);set<int>::iterator it = s1.begin();while (it != s1.end()){// *it = 10;cout << *it << " ";++it;}cout << endl;}
}

3.2. map.h

#pragma once
#include<map>
#include<iostream>
#include"RBTree.h"
using namespace std;namespace zhong
{template<class K, class V>class map{struct MapKetOf{// 通过定义keyOfValue kov 然后 借助()重载 来 找到pair的firstconst K& operator()(const pair<K, V>& value_type) { return value_type.first; }};public:// 这里体现了typename的作用// 对类模板取内嵌类型，需要加typename告知编译器这里是内嵌类型typedef typename RBTree<K, pair<const K, V>, MapKetOf>::iterator iterator;typedef typename RBTree<K, pair<const K, V>, MapKetOf>::const_iterator const_iterator;V& operator[]    (const K& key){// insert返回pair<iterator, bool>，用ret接收插入节点的迭代器，解引用找到这个节点，接着 . 找到seconditerator ret = _tree.insert(make_pair(key, V())).first;return (*ret).second;//pair<iterator, bool> ret = insert(make_pair(key, V()));// return ret.first->second;}// 迭代器iterator begin() { return _tree.begin(); }iterator end() { return _tree.end(); }pair<iterator, bool> insert(const pair<K, V>& value_type) { return _tree.insert(value_type); }private:RBTree<K, pair<const K, V>, MapKetOf> _tree;};void test_map1(){map<string, string> dict;dict.insert(make_pair("name", "zhong"));dict.insert(make_pair("age", "21"));dict.insert(make_pair("id", "2022044026"));map<string, string>::iterator it = dict.begin();while (it != dict.end()){cout << (*it).first << " " << (*it).second << endl;++it;}}void test_map2(){// 测试map中的[]string str[] = { "嗯","哦","噢","喔","好","噢","噢","好" };map<string, int> countMap;for (auto& s : str){// map中实现计数要求// 借助[]重载实现countMap[s]++;// 分成多样的功能}map<string, int>::iterator ret = countMap.begin();while (ret != countMap.end()){cout << (*ret).first << " " << (*ret).second << endl;++ret;}}
}

3.3. RBTree.h

#include<iostream>
#include<vector>
using namespace std;// 实现颜色
enum Colour
{RED,BLACK
};template<class V>
struct RBTreeNode
{// 三叉链结构RBTreeNode<V>* _left;RBTreeNode<V>* _right;RBTreeNode<V>* _parent;V _value;// 实现颜色Colour _col;RBTreeNode(const V& value): _left(nullptr), _right(nullptr), _parent(nullptr), _value(value), _col(RED)	// 默认新节点红色 根节点为黑{}
};template<class V, class Ref, class Ptr>
struct Tree_iterator
{typedef Tree_iterator<V, Ref, Ptr> Self;typedef RBTreeNode<V> Node;Node* _node = nullptr;Tree_iterator(Node* node):_node(node){}// 实现const的拷贝构造Tree_iterator(const Tree_iterator<V, V&, V*>& it):_node(it._node){}Self& operator=(const Self& s){_node = s._node;return *this;}Self& operator++(){// 右子树不为空，遍历到最左节点if (_node->_right != nullptr){Node* current = _node->_right;while (current != nullptr && current->_left != nullptr)current = current->_left;_node = current;}// 右子树为空 大的节点在祖先处else{Node* current = _node;Node* parent = current->_parent;// 如果current在parent的右进入循环，下一个节点就是祖父节点while (parent != nullptr && current == parent->_right){current = parent;parent = parent->_parent;}// 如果current是parent的左，不进入循环，下一个节点就是父亲节点_node = parent;}return *this;}Self& operator--(){if (_node->_left != nullptr){Node* current = _node->_left;while (current != nullptr && current->_right != nullptr)current = current->_right;_node = current;}else{Node* current = _node;Node* parent = current->_parent;while (parent != nullptr && current == parent->_left){current = parent;parent = parent->_parent;}_node = parent;}return *this;}bool operator!=(const Self& s) { return _node != s._node; }bool operator==(const Self& s) { return _node == s._node; }Ref operator*() { return _node->_value; }Ptr operator->() { return &_node->_value; }
};template<class K, class V, class keyOfValue>
class RBTree
{typedef RBTreeNode<V> Node;
public:typedef Tree_iterator<V, V&, V*> iterator;typedef Tree_iterator<V, const V&, const V*> const_iterator;// 迭代器iterator begin(){Node* current = _root;while (current != nullptr && current->_left != nullptr)current = current->_left;return iterator(current);}iterator end(){return iterator(nullptr);}const_iterator begin() const{Node* current = _root;while (current != nullptr && current->_left != nullptr)current = current->_left;return const_iterator(current);}const_iterator end() const{return const_iterator(nullptr);}// 增查pair<iterator, bool> insert(const V& value){// 1.先插入节点if (_root == nullptr){_root = new Node(value);// 根节点默认为黑色_root->_col = BLACK;return make_pair(iterator(_root), true);}Node* parent = nullptr;Node* current = _root;while (current != nullptr){parent = current;if (kov(current->_value) < kov(value))current = current->_right;else if (kov(current->_value) > kov(value))current = current->_left;elsereturn make_pair(iterator(current), false);}Node* newNode = new Node(value);current = newNode;// 新增节点默认为红色current->_col = RED;// 通过大小插入左右if (kov(parent->_value) < kov(value))parent->_right = current;elseparent->_left = current;current->_parent = parent;// 2.实现颜色的变换  情况来回的迭代直至不满足循环 退出时就满足了红黑树while (parent != nullptr && parent->_col == RED){/*进入循环情况：同时满足父节点不为空，且为红色原因： 如果父节点为空，则current为_root如果父节点为黑色，就不用更新颜色了*/Node* grandparent = parent->_parent;// 找到叔叔节点位置if (parent == grandparent->_left){// uncle在父亲右边Node* uncle = grandparent->_right;// 情况一：叔叔存在，且叔叔为红色if (uncle != nullptr && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandparent->_col = RED;// 继续向上调整current = grandparent;parent = current->_parent;}// 情况二：叔叔不存在 或者 叔叔存在但是颜色为黑色else{if (current == parent->_left){RotateR(grandparent);parent->_col = BLACK;grandparent->_col = RED;}// current在右边else{RotateL(parent);RotateR(grandparent);// 通过旋转后，旋转内部就已经完成了指针的指向current->_col = BLACK;grandparent->_col = RED;}// 直接退出循环即可，也可以不退出，因为父亲已经为黑色了break;}}else{// uncle在父亲左边Node* uncle = grandparent->_left;if (uncle != nullptr && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandparent->_col = RED;// 继续向上调整current = grandparent;parent = current->_parent;}else{if (current == parent->_right){RotateL(grandparent);parent->_col = BLACK;grandparent->_col = RED;}// current在左边else {// 注意这里单旋的节点不同RotateR(parent);RotateL(grandparent);grandparent->_col = RED;current->_col = BLACK;}break;}}}// 保持根节点始终为黑色，当current到达根节点可能为RED，这里就在外部变黑_root->_col = BLACK;return make_pair(iterator(newNode), true);}iterator find(const K& key){}// 外部调用封装函数// 中序遍历void inOrder() { _inOrder(_root); cout << endl; }// 判断是否平衡bool ifBalance(){if (_root == nullptr)return true;if (_root->_col == RED)return false;// 作为辅助判断int flag = 0;Node* current = _root;while (current != nullptr){if (current->_col == BLACK)flag++;current = current->_left;}// 设置一个flag值记录某一条路径的长度// 如果flag不等于任何一条路径的长度就表示某一条路径黑色节点数有误cout << "flag大小为：" << flag << endl;// 根节点到当前节点路径上黑色节点数量int blackNum = 0;return check(_root, blackNum, flag);}// 返回树节点个数int size() { return _size(_root); }// 返回树的高度int Height() { return _Height(_root); }// 封装函数区	
private:// 左单旋void RotateL(Node* root){Node* parent = root;Node* subR = parent->_right;Node* subRL = subR->_left;Node* grandparent = parent->_parent;subR->_left = parent;parent->_right = subRL;if (subRL != nullptr)subRL->_parent = parent;parent->_parent = subR;parent = subR;if (grandparent == nullptr){_root = parent;}else{if (grandparent->_left == root)grandparent->_left = parent;elsegrandparent->_right = parent;}parent->_parent = grandparent;}// 右单旋void RotateR(Node* root){Node* parent = root;Node* subL = parent->_left;Node* subLR = subL->_right;Node* grandparent = parent->_parent;subL->_right = parent;parent->_left = subLR;if (subLR != nullptr){subLR->_parent = parent;}parent->_parent = subL;parent = subL;if (grandparent == nullptr){_root = parent;}else{if (grandparent->_left == root)grandparent->_left = parent;elsegrandparent->_right = parent;}parent->_parent = grandparent;}// 中序遍历void _inOrder(Node* root){keyOfValue kov;if (root == nullptr)return;_inOrder(root->_left);cout << kov(root->_value) << " ";_inOrder(root->_right);}// 检查是否出现连续红色节点bool check(Node* root, int blackNum, const int flag){if (root == nullptr){// cout << "黑色节点数目：" << blackNum << endl;if (blackNum != flag){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, flag) && check(root->_right, blackNum, flag);}// 计算树的节点个数int _size(Node* root){if (root == nullptr)return 0;return _size(root->_left) + _size(root->_right) + 1;}// 计算树的高度int _Height(Node* root){if (root == nullptr)return 0;int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}private:Node* _root = nullptr;keyOfValue kov;
};

到了这里通过红黑树初步封装map和set就讲到这里了，我们再来讲一下什么是封装，封装本质就是套个盒子在外面，当我们研究封装好的某一个类时，我们需要逐层剖析，找到封装前到底是什么牛鬼蛇神，进而有助于我们阅读源码