Map和Set的封装

目录

一、底层原理

二、红黑树的节点

三、仿函数

四、迭代器

4.1、迭代器的定义：

4.2、*:解引用操作

4.3、->:成员访问操作符

4.4、!=、==

4.5、迭代器的++：

4.6、迭代器的--

五、Map

六、Set

七、红黑树源码

一、底层原理

我们要知道：Map和Set底层是用红黑树封装的。

红黑树的底层是：KV结构

RBTree是通过传入的Value的值来判断类型，也就是一棵泛型的RBTree，通过不同的实例化，实现出了Map和Set：

对于map:传key，对于set:传pair

为了让我们的红黑树能够识别set与map我们增加一个模板参数T：

template<class K, class T>
class RBTree

对于T模板参数可能是键值Key，也可能是由Key和Value共同构成的键值对。

如果是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容器来说就不行了。

二、红黑树的节点

set容器：K和T都是键值Key; map容器：K是键值Key，T由Key和Value构成的键值对；

但是底层红黑树并不知道上层容器到底是map还是set，因此红黑树的结点当中直接存储T就行了，如果是set的时候，结点当中存储的是键值Key；如果是map的时候，结点当中存储的就是Key和Value构成的键值对,所以红黑树的结点定义如下,由T类型来决定红黑树存的是key还是pair：

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){}
};

三、仿函数

插入的时候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 lyl
{template<class K,class V>class map{struct  MapKeyOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};public:private:RBTree<K, pair<const K,V>,MapKeyOfT> _t;};

set:

namespace lyl
{template<class K>class set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};private:RBTree<K,K,SetKeyOfT> _t;};

我们有了仿函数时，查找函数就可以用仿函数来替换比较部分

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;}
}

四、迭代器

4.1、迭代器的定义：

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){}
}

4.2、*:解引用操作

返回对应结点数据的引用:

Ref operator*(){return _node->_data;}

4.3、->:成员访问操作符

返回结点数据的引用：

Ptr operator->(){return &_node->_data;}

4.4、!=、==

    bool operator !=(const Self & s) const{return _node != s._node;}bool operator ==(const Self& s) const{return _node == s._node;}

4.5、迭代器的++：

一个结点的正向迭代器进行++操作后，根据红黑树中序(左、根、右)找到当前结点的下一个结点，中序的第一个节点是最左，迭代器的++怎么去找：

如果节点的右子树不为空，++就是找右子树的最左节点

如果节点的右子树为空，++就是找祖先（孩子是父亲的左的那个祖先）

	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;}

4.6、迭代器的--

对于–，如果是根，–就是左子树，找到左子树最大的那一个（最右节点）

如果节点的左子树不为空，--找左子树最右的节点

如果节点的左子树为空，--找祖先（孩子是父亲的右的祖先）

    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;}

4.7、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);}
}

五、Map

同样是套用上底层红黑树的接口，不过map的实现有一个很重要的地方，那就是[]的实现

#pragma once
#include "RBTree.h"
namespace lyl
{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_map(){int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };map<int, int> m;for (auto e : a){m.insert(make_pair(e, e));}map<int, int>::iterator it = m.begin();while(it!=m.end()){it->second++;cout << it->first << ":" << it->second << endl;++it;}cout << endl;map<string, int> countMap;string arr[] = { "苹果","西瓜","香蕉","苹果"};for (auto& e : arr){countMap[e]++;}for (auto& kv : countMap){cout << kv.first << ":" << kv.second << endl;}}
}

六、Set

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

七、红黑树源码

#pragma once#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{//情况2if (cur == parent->_left){RotateR(grandfater);parent->_col = BLACK;grandfater->_col = RED;}//情况3else{//       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//        cif (cur == parent->_right){RotateL(grandfater);grandfater->_col = RED;parent->_col = BLACK;}//情况3//     g//         p//      celse{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;
};

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

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

相关文章

vue 阿里图标库引入分享

vue 阿里图标库引入分享

上篇文章分享了element-ui icon 组件的实现原理&#xff0c;文章当中有涉及到了阿里图标库的使用&#xff0c;当时未做详细使用说明&#xff0c;此篇文章是对上篇文章的补充哈。 本篇文章主要分为以下两部分&#xff1a; 一、阿里图标库使用 1.1 阿里图标库地址&#xff1a;…
阅读更多...
029 命令行传递参数

029 命令行传递参数

1.循环输出args字符串数组 public class D001 {public static void main(String[] args) {for (String arg : args) {System.out.println(arg);}} } 2.找打这个类的路径&#xff0c;打开cmd cmd C:\Users\Admin\IdeaProjects\JavaSE学习之路\scanner\src\com\yxm\demo 3. 编译…
阅读更多...
华为机考入门python3--（7）牛客7-取近似值

华为机考入门python3--（7）牛客7-取近似值

分类&#xff1a;数字 知识点&#xff1a; str转float float(str) 向上取整 math.ceil(float_num) 向下取整 math.floor(float_num) 题目来自【牛客】 import math def round_to_int(float_num): # 如果小数点后的数值大于等于0.5&#xff0c;则向上取整&#xf…
阅读更多...
Unity 读取指定目录所占内存大小

Unity 读取指定目录所占内存大小

public static class TxxTool{#region 读取文件大小private static List<string> DirList new List<string>();public static long GetFileSize(string path){DirList new List<string>();DirList.Add(path);GetAllDirecotries(path);long fileSize 0;for…
阅读更多...
c语言--求第n个斐波那契数列（递归、迭代）

c语言--求第n个斐波那契数列（递归、迭代）

目录 一、概念二、用迭代求第n个斐波那契数1.分析2.完整代码3.运行结果4.如果求第50个斐波那契数呢&#xff1f;看看会怎么样。4.1运行结果&#xff1a;4.2画图解释 三、用迭代的方式求第n个斐波那契数列1.分析2.完整代码3.运行结果4.求第50个斐波那契数4.1运行结果4.2运行结果…
阅读更多...
MySQL进阶之锁（表级锁，元数据锁，意向锁）

MySQL进阶之锁（表级锁，元数据锁，意向锁）

表级锁 介绍 表级锁&#xff0c;每次操作锁住整张表。锁定粒度大&#xff0c;发生锁冲突的概率最高&#xff0c;并发度最低。应用在MyISAM、 InnoDB、BDB等存储引擎中。 对于表级锁&#xff0c;主要分为以下三类&#xff1a; 表锁 元数据锁&#xff08;meta data lock&…
阅读更多...
1元竟能驱动170万次AI推理？面壁智能MiniCPM 2B大模型，部署教程 移动端 安卓 苹果 ios android

1元竟能驱动170万次AI推理？面壁智能MiniCPM 2B大模型，部署教程 移动端 安卓 苹果 ios android

在科技日新月异的今天，我们似乎习惯了“更新换代”的节奏。但你有没有想过，那些陪伴我们多年的老手机，也能摇身一变成为AI神器？面壁智能的MiniCPM 2B大模型，就给我们带来了这样的惊喜。 你可能不知道，这个仅有20亿参数的大模型，却拥有“越级打怪”的实力。与业内知名的…
阅读更多...
如何搭建私有云盘SeaFile并实现远程访问本地文件资料

如何搭建私有云盘SeaFile并实现远程访问本地文件资料

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法 ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” #mermaid-svg-hsDnDEybLME85dTx {font-family:"trebuchet ms",verdana,arial,sans-serif;font-siz…
阅读更多...
Web自动化测试理论知识

Web自动化测试理论知识

1、自动化测试概述 概念&#xff1a;用工具代替/辅助人工完成完成软件测试活动的过程 特点&#xff1a; 可以对程序的新版本自动执行回归测试 可以执行一些手工测试困难或不可能进行的测试 可以更好地利用资源 测试具有一致性和可重复性 误区&#xff1a; …
阅读更多...
安装配置sqoop

安装配置sqoop

一、了解Sqoop 1、Sqoop产生的原因 A. 多数使用hadoop技术的处理大数据业务的企业，有大量的数据存储在关系型数据中。 B. 由于没有工具支持，对hadoop和关系型数据库之间数据传输是一个很困难的事。 以上是sqoop产生的主要原因，也因此Sqoop主要用于hadoop与关系型数据库之…
阅读更多...
树莓派与Win11通信【一对一】（四）

树莓派与Win11通信【一对一】（四）

树莓派与Win11通信【一对一】&#xff08;四&#xff09; 树莓派与Win11通信【一对一】&#xff08;四&#xff09;的代码优化版&#xff0c; 最近给代码添加了打开摄像头与否的验证&#xff0c;以及文件的保存&#xff0c;定时拍摄 1.Server端 import socket import time …
阅读更多...
【数据结构 09】哈希

【数据结构 09】哈希

哈希算法&#xff1a;哈希也叫散列、映射&#xff0c;将任意长度的输入通过散列运算转化为固定长度的输出&#xff0c;该输出就是哈希值&#xff08;散列值&#xff09;。 哈希映射是一种压缩映射&#xff0c;通常情况下&#xff0c;散列值的空间远小于输入值的空间。 哈希运…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023