C++实现map和set封装详解
更新时间：2024年03月25日 08:40:20 作者：დ旧言~
欢迎阅读本指南,将带您深入了解C++中map和set的实现细节,本文将重点介绍如何使用C++标准库中的容器来优化代码,同时提供实用的示例和技巧,无论您是初学者还是资深开发者,本指南都将成为您掌握C++中map和set封装的有力助手,需要的朋友可以参考下
前言
map和set的知识我们学习了，模拟实现我们已经实现了AVL树和红黑树。熟练知识点为map和set的使用提供了前提，手撕AVL树和红黑树让我了解到map和set的底层如何实现，有了知识点和两树的模拟铺垫，那我们该如何封装map和set呢？
主体
学习map和set封装咱们按照下面的图解：
map/set底层原理
Map和Set底层是用红黑树封装的，而红黑树结构是KV结构。
RBTree是通过传入的Value的值来判断类型，也就是一棵泛型的RBTree，通过不同的实例化，实现出了Map和Set，对于map:传key，对于set:传pair，如图：
简化后的map源码：
简化后的set源码：
我们查看源码后，因此在封装我们map和set时，让我们的红黑树增加一个模板参数T来识别map和set，代码如下：（此处的代码是修改了红黑树）
template<class K, class T> class RBTree
分析原理：
如果是set容器，那么它传入底层红黑树的模板参数就是Key和Key：
template<class K> class set { private: RBTree<K,K> _t; };如果是map容器，传入底层红黑树的模板参数就是Key和Key和value的键值对：
class map { private: RBTree<K, pair<const K,V>> _t; };
问题拓展：
通过上面，我们可以知道，对于set和map的区别：我们只要通过第二个模板参数就能进行区分那是不是第一个模板参数就没有意义了呢？
对于insert(const Value&v)来说，需要放入存入的值，确实是这个样子的，插入的值是value，对于set就是key，对于map就是pair。但是对于find(const Key&key)来说，查找的参数不是value，找的不是pair而是Key，对于map容器来说就不行了。
map/set定义
map和set封装都用头文件来，代码如下：
set：
template<class K> class set { private: RBTree<K,K> _t; };map：
class map { private: RBTree<K, pair<const K,V>> _t; };
map/set仿函数
问题阐述：
插入的时候data的大小如何去进行比较：我们并不知道是什么类型是key，还是pair的比较，而我们刚开始kv结构就直接用kv.first去比较了。
对于set是Key，可以比较对于map是pair，那我们要取其中的first来比较，但是pair的大小并不是直接按照first去进行比较的，而我们只需要按照first去进行比较
问题分析：
由于底层的红黑树不知道传的是map还是set容器，当需要进行两个结点键值的比较时，底层红黑树传入的仿函数来获取键值Key，进行两个结点键值的比较：这个时候我们就需要仿函数了，如果是set那就是用于返回T当中的键值Key,如果是map那就是用于返回pair的first：
注意事项：
仿函数/函数对象也是类，是一个类对象。仿函数要重载operator()。
代码实现：
map：
namespace lyk { template<class K, class V> class map { struct MapkeyOfT // 仿函数 { const K& operator()(const pair<const K, V>& kv) { return kv.first; } }; }set：
namespace lyk
{
template <class K>
class set // 仿函数，重载operator()
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
}图示：
我们有了仿函数时，查找函数就可以用仿函数来替换比较部分
KeyOfT kot;//仿函数对象
Node* parent = nullptr;
Node* cur = _root;
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;
}
}map/set插入
接下来 map/set 的插入直接套用红黑树的即可，代码如下：
//map的插入，插入pair
bool insert(const pair<K, V>& kv)
{
return _t.Insert(kv);
}
//set的插入，插入key
bool insert(const K& key)
{
return _t.Insert(key);
}map/set迭代器
迭代器的定义
template<class T,class Ref,class Ptr>
struct __RBTreeIterator
{
typedef RBTreeNode<T> Node;
typedef __RBTreeIterator<T,Ref,Ptr> Self;
typedef __RBTreeIterator<T, T&, T*> iterator;
Node* _node;
__RBTreeIterator(Node*node)
:_node(node)
{}
//普通迭代器的时候，它是拷贝构造
//const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
__RBTreeIterator(const iterator& s)
:_node(s._node)
{}
}解引用操作
作用：返回对应结点数据的引用
Ref operator*()
{
return _node->_data;
}成员访问操作符
作用：返回结点数据的引用
Ptr operator->()
{
return &_node->_data;
}!=、==
bool operator !=(const Self & s) const
{
return _node != s._node;
}
bool operator ==(const Self& s) const
{
return _node == s._node;
}begin() 与 end()
begin()：返回中序（左、根、右）第一个结点的正向迭代器，即最左节点，返回的是最左节点,直接找最左节点即可
end()：返回中序（左、根、右）最后一个结点下一个位置的正向迭代器，这里直接用空指针
template<class K, class T,class KeyOfT>
class RBTree
{
typedef RBTreeNode<T> Node;
public:
typedef __RBTreeIterator<T> iterator;
iterator begin()
{
Node* left = _root;
while (left && left->_left)
{
left = left->_left;
}
return iterator(left);
}
iterator end()
{
return iterator(nullptr);
}
}迭代器的++
一个结点的正向迭代器进行++操作后，根据红黑树中序(左、根、右)找到当前结点的下一个结点，中序的第一个节点是最左，迭代器的++怎么去找：
如果节点的右子树不为空，++就是找右子树的最左节点如果节点的右子树为空，++就是找祖先（孩子是父亲的左的那个祖先）
Self& operator++()
{
if (_node->_right)
{
Node* min = _node->_right;
while (min->_left)
{
min = min->_left;
}
_node = min;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_right)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}迭代器的--
对于–，如果是根，–就是左子树，找到左子树最大的那一个（最右节点）
如果节点的左子树不为空，--找左子树最右的节点如果节点的左子树为空，--找祖先（孩子是父亲的右的祖先）
Self& operator--()
{
if (_node->_left)
{
Node* max = _node->_left;
while (max->_right)
{
max = max->_right;
}
_node = max;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent&&cur==parent->_left)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}源代码及其测试
map代码
#include"RBTree.h"
namespace lyk
{
template<class K, class V>
class map
{
struct MapkeyOfT // 仿函数
{
const K& operator()(const pair<const K, V>& kv)
{
return kv.first;
}
};
public:
//typename:没有实例化的模板，区分不了是静态变量还是类型，typename告诉编译器是类型
typedef typename RBTree<K, pair<const K, V>, MapkeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapkeyOfT>::const_iterator
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();
}
pair<iterator, bool> insert(const pair<const K, V>& kv)
{
return _t.Insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
private:
RBTree<K, pair<const K, V>, MapkeyOfT> _t;
};
void test_map1() // 测试代码
{
map<int, int> m;
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
m.insert(make_pair(e, e));
}
map<int, int>::iterator it = m.begin();
while (it != m.end())
{
//it->first += 100;
it->second += 100;
cout << it->first << ":" << it->second << endl;
++it;
}
cout << endl;
}
}set代码
#include"RBTree.h"
namespace lyk
{
template <class K>
class set // 仿函数，重载operator()
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
//typename:没有实例化的模板，区分不了是静态变量还是类型，typename告诉编译器是类型
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;//key不可以修改
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
iterator begin() const
{
return _t.begin();
}
iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const K& key)
{
//底层红黑树的iterator是普通迭代器
pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
return pair<iterator, bool>(ret.first, ret.second);//用普通迭代器构造const迭代器
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
void test_set1() // 测试代码
{
set<int> s;
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
s.insert(e);
}
set<int>::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
}红黑树代码
#pragma once
#include <iostream>
#include <assert.h>
#include <time.h>
using namespace std;
enum Color
{
RED,
BLACK,
};
template<class T>
struct RBTreeNode
{
T _data;
RBTreeNode<T>* _left;
RBTreeNode<T>* _right;
RBTreeNode<T>* _parent;
Color _col;
RBTreeNode(const T& data)
:_data(data)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _col(RED)
{}
};
template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
typedef RBTreeNode<T> Node;
typedef __RBTreeIterator<T, Ref, Ptr> Self;
typedef __RBTreeIterator<T, T&, T*> iterator;
Node* _node;
__RBTreeIterator(Node* node)
:_node(node)
{}
//普通迭代器的时候，它是拷贝构造
//const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
__RBTreeIterator(const iterator& s)
:_node(s._node)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()
{
if (_node->_right)
{
Node* min = _node->_right;
while (min->_left)
{
min = min->_left;
}
_node = min;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_right)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
Self& operator--()
{
if (_node->_left)
{
Node* max = _node->_left;
while (max->_right)
{
max = max->_right;
}
_node = max;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_left)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
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
{
typedef RBTreeNode<T> Node;
public:
typedef __RBTreeIterator<T, T&, T*> iterator;
typedef __RBTreeIterator<T, const T&, const T*> const_iterator;
const_iterator begin() const
{
Node* left = _root;
while (left && left->_left)
{
left = left->_left;
}
return const_iterator(left);
}
const_iterator end() const
{
return const_iterator(nullptr);
}
iterator begin()
{
Node* left = _root;
while (left && left->_left)
{
left = left->_left;
}
return iterator(left);
}
iterator end()
{
return iterator(nullptr);
}
pair<iterator, bool> Insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return make_pair(iterator(_root), true);
}
KeyOfT kot;
Node* parent = nullptr;
Node* cur = _root;
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 make_pair(iterator(cur), false);
}
}
cur = new Node(data);
Node* newnode = cur;
cur->_col = RED;
if (kot(parent->_data) < kot(data))
{
parent->_right = cur;
cur->_parent = parent;
}
else
{
parent->_left = cur;
cur->_parent = parent;
}
while (parent && parent->_col == RED)
{
Node* grandfater = parent->_parent;
if (parent == grandfater->_left)
{
Node* uncle = grandfater->_right;
//情况一：u存在且为红
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandfater->_col = RED;
//向上调整
cur = grandfater;
parent = cur->_parent;
}
else
{
//情况2
if (cur == parent->_left)
{
RotateR(grandfater);
parent->_col = BLACK;
grandfater->_col = RED;
}
//情况3
else
{
// g
// p
// c
RotateL(parent);
RotateR(grandfater);
cur->_col = BLACK;
grandfater->_col = RED;
}
break;
}
}
else//parent==grandfater->_right
{
Node* uncle = grandfater->_left;
//情况1：u存在且为红色
if (uncle && uncle->_col == RED)
{
uncle->_col = parent->_col = BLACK;
grandfater->_col = RED;
//向上调整
cur = grandfater;
parent = cur->_parent;
}
else
{
//情况2：u不存在/u存在为黑色
//g
// p
// c
if (cur == parent->_right)
{
RotateL(grandfater);
grandfater->_col = RED;
parent->_col = BLACK;
}
//情况3
// g
// p
// c
else
{
RotateR(parent);
RotateL(grandfater);
cur->_col = BLACK;
grandfater->_col = RED;
}
break;
}
}
}
//根变黑
_root->_col = BLACK;
return make_pair(iterator(newnode), true);
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* ppNode = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (ppNode == nullptr)
{
_root = subR;
_root->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else
{
ppNode->_right = subR;
}
subR->_parent = ppNode;
}
}
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* ppNode = parent->_parent;
parent->_parent = subL;
subL->_right = parent;
if (ppNode == nullptr)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
}
void InOrder()
{
_InOrder(_root);
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
bool Check(Node* root, int blackNum, int ref)
{
if (root == nullptr)
{
//cout << blackNum << endl;
if (blackNum != ref)
{
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, ref)
&& Check(root->_right, blackNum, ref);
}
bool IsBalance()
{
if (_root == nullptr)
{
return true;
}
if (_root->_col != BLACK)
{
return false;
}
int ref = 0;
Node* left = _root;
while (left)
{
if (left->_col == BLACK)
{
++ref;
}
left = left->_left;
}
return Check(_root, 0, ref);
}
private:
Node* _root = nullptr;
};
测试
测试set：
测试map：
到此这篇关于C++实现map和set封装详解的文章就介绍到这了,更多相关C++ map和set封装内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
您可能感兴趣的文章:
- C++用一棵红黑树同时封装出set与map的实现代码
- C++使用一棵红黑树同时封装出map和set实例代码
- C++ map与set封装实现过程讲解
- C++中map和set封装实现示例
- C++深入探究哈希表如何封装出unordered_set和unordered_map
- c++容器list、vector、map、set区别与用法详解
- C++ STL入门教程(7) multimap、multiset的使用
- C++中map和set的简介及使用详解
- C++中set/multiset与map/multimap的使用详解
- C++中map和set的使用详细攻略
- C++中常见容器类的使用方法详解(vector/deque/map/set)
相关文章
这篇文章介绍了c++ builder TreeView控件节点遍历代码，有需要的朋友可以参考一下2013-09-09
今天小编就为大家分享一篇关于C语言实现模拟USB对8bit数据的NRZI编码输出，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧2018-12-12
这篇文章主要介绍了Visual Studio下Eigen库环境配置方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-12-12
这篇文章主要介绍了Linux内核的基本的模块管理与时间管理操作,包括模块加载卸载函数的使用和定时器的用法等知识,需要的朋友可以参考下2016-02-02
异常处理是C++的一项语言机制,用于在程序中处理异常事件,下面这篇文章主要给大家介绍了关于C++中异常的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下2022-02-02
这篇文章主要为大家详细介绍了C++17中std::byte的具体使用,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下2023-11-11
这里尝试通过C++来实现一个文件IO的功能，看看是否能够比python的表现更好一些,感兴趣的朋友可以参考下2021-05-05
单链表是后面要学的双链表以及循环链表的基础，要想继续深入了解数据结构以及C语言，我们就要奠定好这块基石！接下来就和我一起学习吧2022-04-04
Qt图形图像开发之曲线图表模块QChart库一个chart中显示两条曲线详细方法与实例
这篇文章主要介绍了Qt图形图像开发之曲线图表模块QChart库一个chart中显示两条曲线详细方法与实例,需要的朋友可以参考下2020-03-03
这篇文章主要介绍了C++语言中的二元运算符和赋值运算符,文中列出了可重载的运算符列表,需要的朋友可以参考下2016-01-01
最新评论