我们知道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就讲到这里了,我们再来讲一下什么是封装,封装本质就是套个盒子在外面,当我们研究封装好的某一个类时,我们需要逐层剖析,找到封装前到底是什么牛鬼蛇神,进而有助于我们阅读源码
封装是面向对象编程中的一种重要特性,它指的是将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部的信息,而是通过该类所提供的方法来实现对内部信息的操作和访问。封装可以有效地保护对象的数据安全性,同时也可以提高代码的可维护性和可重用性。