改造哈希表，封装unordered_map和unordered_set

news2024/11/20 3:30:00

正文开始前给大家推荐个网站，前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

unordered_map是存的是pair是K，V型的，而unordered_set是K型的，里面只存一个值，那我们如何利用一个数据结构将他们都封装出来呢？

我们知道哈希表我们实现的是存pair的，我们可以使用最笨的方法直接复制一份，把存pair的改为存Key的，但是我们可以参考一下大佬的做法，大佬直接把存的东西弄成一个模版参数，这个东西具体存的啥由用户来决定，用户传什么就存什么，所以改造后的哈希表的第二个类型模版参数就是我们要存的类型！

template <class T>
struct HashNode
{
	T _data;
	HashNode* _next;

	HashNode(const T& data)
		: _data(data)
		, _next(nullptr)
	{}
};
template <class K, class V,class KeyOfT, class Hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<V> Node;
private:
	KeyOfT kt;
	vector<Node*> _tables;
	size_t _n = 0;
	Hash hs;
};

我们可以看到V是什么类型，那么这个哈希表中存的就是什么，但是会有下一个问题，我们在取余时，不管是unordered_map还是unordered_set都是对Key取余，但是这里我们不知道他是Key还是pair，那怎么办呢？

我们可以通过仿函数解决这个问题，我们每个需要用Key计算的地方都走一层仿函数，然后unordered_set的就直接返回key就行，unordered_map则需要返回pair的first。我们会看到上面的结果多了个KeyOfT的模版，这个就是返回Key的仿函数。

unordered_map

template<class K, class V>
class unordered_map
{
	struct MapKOfT
	{
		const K& operator()(const pair<const K, V>& kv)
		{
			return kv.first;
		}
	};
	private:
	hash_bucket::HashTable<K, pair<K,V>,MapKOfT> _ht;
};

unordered_set

template<class K>
class unordered_set
{
	struct SetKOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
		private:
	hash_bucket::HashTable<K, K,SetKOfT> _ht;
};

至此我们最简单的框架就搭建出来了。需要注意的是所有需要用Key的地方都要走一层仿函数。
插入删除什么的直接复用哈希表的就可以，就下来主要就是实现迭代器。

迭代器

迭代器的结构应该是什么样子的？
节点的指针肯定是必须的，但是如果我们当前的桶走完了，如何++到下一个桶呢？
所以我们需要这张哈希表，用来找当前桶走完以后的下一个桶。这里不传这张哈希表也是可以的，因为我们的目的是找下一个桶，所以把哈希表中的vector传过来也是可以的。

那么迭代器如何++呢？

如果他的下一个节点是空，那么就说明这个桶走完了，我们需要找下一个桶，所以我们需要当前的位置，所以我们可以直接把当前桶的位置传过来，也可以当场计算桶的位置，这两种方法都是可以的，但是如果这张表走完了还没找到下一个桶，那就说明这张表走完了，我们直接把节点的指针改为nullptr即可。
如果它的下一个节点不为空，那直接让它等于它的next即可。

const的迭代器我们可以和之前一样，直接用两个模版参数来决定它是普通迭代器还是const迭代器。

template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash = HashFunc<K>>
struct __HTIterator
{
	typedef HashNode<V> Node;
	typedef __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash> Self;

	Node* _node;
	const HashTable<K, V, KeyOfT, Hash>* _pht;
	size_t hashi;
	__HTIterator(Node* node,const HashTable<K, V, KeyOfT, Hash>* pht,size_t i)
		: _node(node)
		, _pht(pht)
		, hashi(i)
	{}


	Self operator++()
	{
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else
		{
			++hashi;
			while (hashi < _pht->_tables.size())
			{
				if (_pht->_tables[hashi])
				{
					_node = _pht->_tables[hashi];
					break;
				}
				++hashi;
			}
			if (hashi == _pht->_tables.size())
			{
				_node = nullptr;
			}
		}

		return *this;
	}

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

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

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

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

但是这里会有一个相互依赖的问题，就是哈希表需要用迭代器，迭代器需要用哈希表，如果哈希表在前面我们就需要前置声明一下迭代器，迭代器同理，我们需要在前面声明一个哈希表，但是解决完这个问题以后还存在一个问题，就是哈希表中的vector是私有成员，迭代器不能直接访问，所以我们需要把迭代器声明为哈希表的友元。
在这里插入图片描述

在这里插入图片描述
把迭代器实现好以后，接下来就是解决Key不能修改的问题。
unordeted_set和unordeted_map如何实现Key不能修改呢？
我们通过观察原码会发现unordeted_set迭代器和const迭代器都是const迭代器，它是通过这样的方式来实现的。unordeted_map是Key不能修改而Value是可以修改的，所以它的pair是pair<const K,V>它把Key设置为const，这样就能够保证Key不能修改，Value可以修改。

接下来需要实现的是unordered_map的[]重载，要实现这个重载我们就需要对哈希表的插入进行修改，它的返回值不能再是一个bool值，而是一个pair，这个pair的first是iterator迭代器，second是bool类型代表是否插入成功。改造完以后，就可以实现[]重载，但是对应容器的插入的返回值也需要变一下，[]重载主要就是存在就插入不存在就不插入，但是都会返回Val的是可以别被我们修改。

当改造完插入以后，我们会发现unordered_set的插入编译编不过，这是因为unordered_set的迭代器都是const迭代器，而哈希表的插入返回的是普通的迭代器，这里的iterator无法转化为const_iterator，所以编译错误，有两种方式可以解决，我们可以支持const迭代器转化为普通迭代器，我们也可以直接用const中的东西来构造新的普通迭代器。此时我们的封装差不多就完善了。

改造后的哈希表

namespace hash_bucket
{
	template <class T>
	struct HashNode
	{
		T _data;
		HashNode* _next;

		HashNode(const T& data)
			: _data(data)
			, _next(nullptr)
		{}
	};

	template <class K, class V, class KeyOfT, class Hash>
	class HashTable;

	template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash = HashFunc<K>>
	struct __HTIterator
	{
		typedef HashNode<V> Node;
		typedef __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash> Self;

		Node* _node;
		const HashTable<K, V, KeyOfT, Hash>* _pht;
		size_t hashi;
		__HTIterator(Node* node,const HashTable<K, V, KeyOfT, Hash>* pht,size_t i)
			: _node(node)
			, _pht(pht)
			, hashi(i)
		{}


		Self operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				++hashi;
				while (hashi < _pht->_tables.size())
				{
					if (_pht->_tables[hashi])
					{
						_node = _pht->_tables[hashi];
						break;
					}
					++hashi;
				}
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}

			return *this;
		}

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

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

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

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

	template <class K, class V,class KeyOfT, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<V> Node;

		template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash>
		friend struct __HTIterator;

	public:
		typedef __HTIterator<K, V, V&, V*, KeyOfT, Hash> iterator;
		typedef __HTIterator<K, V, const V&,const V*,KeyOfT, Hash> const_iterator;

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return iterator(_tables[i], this, i);
				}
			}
			return end();
		}

		iterator end()
		{
			return iterator(nullptr, this, -1);
		}

		const_iterator begin() const
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return const_iterator(_tables[i], this, i);
				}
			}
			return end();
		}

		const_iterator end() const
		{
			return const_iterator(nullptr, this, -1);
		}
		HashTable()
		{
			_tables.resize(10);
		}

		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		pair<iterator,bool> Insert(const V& data)
		{
			iterator ret = Find(kt(data));
			if (ret!=end())
			{
				return make_pair(ret,false);
			}

			if (_n == _tables.size())
			{
				//需要扩容
				vector<Node*> newtables;
				newtables.resize(2 * _tables.size());

				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hs(kt(cur->_data))% newtables.size();
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}

				_tables.swap(newtables);
			}

			size_t hashi = hs(kt(data)) % _tables.size();
			Node* cur = new Node(data);
			cur->_next = _tables[hashi];
			_tables[hashi] = cur;
			_n++;
			return make_pair(iterator(cur,this,hashi), true);
		}

		//__HTIterator<K, V, V&, V*, KeyOfT, Hash>
		// __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash>
		iterator Find(const K& k)
		{
			size_t hashi = hs(k) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kt(cur->_data) == k)
				{
					return iterator(cur,this,hashi);
				}

				cur = cur->_next;
			}

			return end();
		}

		bool Erase(const K& k)
		{
			size_t hashi = hs(k) % _tables.size();

			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == k)
				{
					if (prev==nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				cur = cur->_next;
			}

			return false;
		}
	private:
		KeyOfT kt;
		vector<Node*> _tables;
		size_t _n = 0;
		Hash hs;
	};
}

封装的unordered_map

template<class K, class V>
	class unordered_map
	{
		struct MapKOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKOfT>::iterator iterator;
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		const_iterator begin() const
		{
			return _ht.begin();
		}

		const_iterator end() const
		{
			return _ht.end();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));

			return ret.first->second;
		}
	private:
		hash_bucket::HashTable<K, pair<const K,V>,MapKOfT> _ht;
	};

封装的unordered_set

template<class K>
class unordered_set
{
	struct SetKOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename hash_bucket::HashTable<K, K, SetKOfT>::const_iterator iterator;
	typedef typename hash_bucket::HashTable<K, K, SetKOfT>::const_iterator const_iterator;

	iterator begin() const 
	{
		return _ht.begin();
	}

	iterator end() const
	{
		return _ht.end();
	}

	pair<iterator, bool> insert(const K& key)
	{
		auto ret = _ht.Insert(key);
		return make_pair(iterator(ret.first._node, ret.first._pht,ret.first.hashi), ret.second);
	}

private:
	hash_bucket::HashTable<K, K,SetKOfT> _ht;
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

恒创：更换服务器，网站备案会掉吗

恒创：更换服务器，网站备案会掉吗

随着互联网的普及&#xff0c;越来越多的企业和个人选择通过网站来展示自己的形象和业务。然而&#xff0c;在网站建设和运营过程中&#xff0c;更换服务器是一个常见的问题。那么&#xff0c;更换服务器后&#xff0c;网站备案是否会受到影响呢&#xff1f; 网站备案是为了保…
阅读更多...
docker-compose 升级；yaml文件编写；gpu使用

docker-compose 升级；yaml文件编写；gpu使用

1、docker-compose 升级&#xff08;现在已经2.*版本&#xff0c;升级使支持gpu&#xff09; 参考&#xff1a;https://blog.csdn.net/weixin_51311218/article/details/131376823 https://github.com/docker/compose/issues/8142 1&#xff09;下载&#xff1a;原来1.18&…
阅读更多...
11、ble_mesh_provisioner 配网器

11、ble_mesh_provisioner 配网器

1、初始化流程&#xff0c;存储初始化&#xff0c;nvs擦除&#xff0c; 2、bluetooth_init();ble协议栈初始化 3、ble_mesh_get_dev_uuid(dev_uuid);//获取设备uuid加载到mac. 4、ble_mesh_init();//ble mesh协议栈初始化 4.1配置网络钥匙&#xff0c;索引&#xff0c;赋…
阅读更多...
微信视频号视频加密逆向

微信视频号视频加密逆向

tl;dr 拿WxIsaac64(Isaac64的变种?)生成2^17个字节。然后和视频的前2^17字节做异或。 前言 略去, 总之就是WeChatVideoDownloader不能用了。 原文链接: here 准备工作 在正式开始逆向之前&#xff0c;我们首先需要能够在微信视频号中打开开发者工具&#xff0c;由于微信…
阅读更多...
vue3+echarts 立体柱状效果

vue3+echarts 立体柱状效果

vue3echarts 立体柱状效果 废话不多说&#xff0c;直接上代码 就两步&#xff0c;直接复制粘贴一手 <div id"main" class"chart" ref"chartDom"></div>import * as echarts from echarts; type EChartsOption echarts.EChartsOpti…
阅读更多...
c YUV 转 JPEG（准备霍夫曼编码）

c YUV 转 JPEG（准备霍夫曼编码）

先取yuv 文件中一个168的块&#xff0c;跑通全流程 理解与思路&#xff1a; 1.块分割 YUV 文件分为&#xff1a;YUV444 YUV 422 YUV420。444:就是&#xff1a;12个char 有4个Y&#xff0c;4个U&#xff0c;4个 U&#xff0c;422&#xff1a;8个char 中有4个Y &#x…
阅读更多...
网络渗透测试（1）

网络渗透测试（1）

实验1&#xff1a;用搜索引擎Google或百度搜索麻省理工学院网站中文件名包含“network security”的pdf文档&#xff0c;截图搜索得到的页面。 实验2&#xff1a;brassserie&#xff08;题目中给到的餐厅名称&#xff09; 实验3 实验4&#xff1a;将Z29vZCBnb29kIHN0dWR5IQ解…
阅读更多...
攻防世界题目练习——Web引导模式（五）（持续更新）

攻防世界题目练习——Web引导模式（五）（持续更新）

题目目录 1. FlatScience2. bug3. Confusion1 1. FlatScience 参考博客&#xff1a; 攻防世界web进阶区FlatScience详解 题目点进去如图&#xff0c;点击链接只能看到一些论文pdf 用dirsearch和御剑扫描出一些隐藏文件&#xff1a; robots.txt: admin.php: login.php: f…
阅读更多...
《人工智能导论》知识思维导图梳理【第7章节】

《人工智能导论》知识思维导图梳理【第7章节】

文章目录 说明专家系统机器学习机器学习定义工作流程模型评估机器学习分类在这里插入图片描述 机器学习部分md内容机器学习1 机器学习定义机器学习是从数据中自动分析获得模型&#xff0c;并利用模型对未知数据进行预测机器学习&#xff08;machine learning&#xff09;使计算…
阅读更多...
美容店预约小程序搭建指南

美容店预约小程序搭建指南

随着互联网的发展&#xff0c;越来越多的传统行业开始尝试将业务与互联网相结合&#xff0c;以提供更加便捷、高效的服务。美容行业也不例外。本文将通过使用第三方制作平台&#xff0c;如乔拓云网&#xff0c;指导您如何搭建一个美观实用的美容店预约小程序&#xff0c;帮助您…
阅读更多...
计算机网络：物理层（编码与调制）

计算机网络：物理层（编码与调制）

今天又学会了一个知识&#xff0c;加油&#xff01; 目录 一、基带信号与宽带信号 1、基带信号 2、宽带信号 3、选择 4、关系 二、数字数据编码为数字信号 1、非归零编码【NRZ】 2、曼彻斯特编码 3、差分曼彻斯特编码 4、归零编码【RZ】 5、反向不归零编码【NRZI】 …
阅读更多...
云计算 云原生

云计算 云原生

一、引言 云计算需要终端把信息上传到服务器&#xff0c;服务器处理后再返回给终端。在之前人手一台手机的情况下&#xff0c;云计算还是能handle得过来的。但是随着物联网的发展&#xff0c;什么东西都要联网&#xff0c;那数据可就多了去了&#xff0c;服务器处理不过来&…
阅读更多...
绘图示例---QT手动调用绘图事件，按钮控制图片

绘图示例---QT手动调用绘图事件，按钮控制图片

效果&#xff1a; 点击 “移动” 图片向右移动20&#xff0c;点击 “西理win嘛” 图片每秒向右移动20 QQ录屏20231212164128 下面时代码详解&#xff1a; 注意使用UI和代码实现按钮的不同 UI: ui->pushButton->setGeometry(windowWidth-105, windowHeight-25, 100, 20);…
阅读更多...
【分享】WinRAR解压缩软件的超详细使用攻略

【分享】WinRAR解压缩软件的超详细使用攻略

WinRAR是一款常见的解压缩软件&#xff0c;它使用方便&#xff0c;界面友好&#xff0c;在压缩率和速度方面都有很好的表现。 除了解压缩功能&#xff0c;WinRAR还有很多好用的功能&#xff0c;今天小编就来分享一下&#xff0c;WinRAR几个常用功能的具体使用方法。 1. 解压缩…
阅读更多...
1.7 实战：Postman请求Post接口-登录

1.7 实战：Postman请求Post接口-登录

上一小节我们实战了使用Postman请求Get接口。本小节我们来使用Postman请求Post接口。 我们来测试一下登录，之前已经创建好了Collections。我们选择登录页下的登录这个请求。地址也是跟之前一样，我们打开校园二手交易系统，打开浏览器开发者工具，输入用户名和密码，点击登录…
阅读更多...
【ET8框架入门】0.ET框架介绍

【ET8框架入门】0.ET框架介绍

ET8 新特性 多线程多进程架构,架构更加灵活强大&#xff0c;多线程设计详细内容请看多线程设计课程抽象出纤程(Fiber)的概念&#xff0c;类似erlang的进程&#xff0c;非常轻松的创建多个纤程&#xff0c;利用多核&#xff0c;仍然是单线程开发的体验纤程调度: 主线程&#xf…
阅读更多...
语义分割和数据集

语义分割和数据集

语义分割和数据集 参考:https://zh.d2l.ai/chapter_computer-vision/semantic-segmentation-and-dataset.html 语义分割可以理解为识别并理解图像重每一个像素的内容 计算机视觉领域还有2个和语义分割相似的问题&#xff0c;即图像分割和实例分割 图像分割将图像划分为若干组…
阅读更多...
基于物理的AlGaN/GaN HEMT器件2DEG电荷密度分析模型（文献阅读）

基于物理的AlGaN/GaN HEMT器件2DEG电荷密度分析模型（文献阅读）

标题&#xff1a;A Physics-Based Analytical Model for 2DEG Charge Density in AlGaN/GaN HEMT Devices (IEEE TRANSACTIONS ON ELECTRON DEVICES) 重要公式 2DEG电荷密度建模的困难源于量子阱中Ef随ns的复杂变化。此关系由给出 n s D V t h [ l n ( l e E f − E 0 V t …
阅读更多...
Leetcode 455 分发饼干

Leetcode 455 分发饼干

题意理解&#xff1a; 小孩的饭量&#xff1a; [1,2,7,10] 饼的大小&#xff1a; [1,3,5,7] 当饼的大小>小孩饭量时&#xff0c;小孩就能够吃饱。 求如何分配饼让更多的小孩子能够吃饱。 解题思路&#xff1a; 两种思路&#xff1a; 先把胃口小的孩子用较小的饼来喂饱—…
阅读更多...
Oracle MongoDB

Oracle MongoDB

听课的时候第一次碰到&#xff0c;可以了解一下吧&#xff0c;就直接开了墨者学院的靶场 #oracle数据库 Oracle数据库注入全方位利用 - 先知社区 这篇写的真的很好 1.判断注入点 当时找了半天没找到 看样子是找到了&#xff0c;测试一下看看 id1 and 11 时没有报错 2.判断字段…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023