【c++】模拟实现unordered_set和unordered_map

最新推荐文章于 2024-07-22 23:59:01 发布
最新推荐文章于 2024-07-22 23:59:01 发布
阅读量484 收藏 1
点赞数 5
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61438674/article/details/130752390
版权

使用哈希桶来进一步模拟实现unordered系列的两个容器：unordered_set和unordered_map.

1. 节点模板

unordered_set 是 K 模型的容器 unordered_map 是 KV 模型的容器,所以需要对结点的参数进行改造使这两个容器都能使用。对于unordered_set 来说_data 中存的是K，对于unordered_map来说_data中存的是一个由K和V组成的键值对。

	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

2.KeyofT仿函数

插入元素时通过哈希函数计算出对应的哈希地址：但是插入的时候就不能直接用data去进行比较了因为unordered_map的data是键值对,键值对不能比较，需要取出键值对的first。而data既可以是unordered_set的，也可以是unordered_map的，所以我们需要仿函数来实现不同容器所对应的需求。

unordered_map的仿函数：

template<class K,class V,class Hash=HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
    }
	private:
		buckethash::HashTable<K, pair<const K, V>, Hash, MapKeyOfT> _ht;
	};

unordered_set 的仿函数：

template<class K,class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
     private: 
		buckethash::HashTable<K, K, Hash, SetKeyOfT> _ht;
	};

3.哈希函数

在插入数据时，要根据数据的关键码求出存储位置的对应关系。这里哈希函数采用的方法是除留余数法，但是字符串是没办法取模的，所以string需要特化，让string类型的数据也能对应一个存储位置。符合string类型的优先走string的函数。

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>   //符合string类型的优先走string类型
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}
		return hash;
	}
};


4.正向迭代器

哈希表的正向迭代器对哈希表指针和结点指针进行了封装，operator++可以访问下一个非空的桶中的元素，所以每个正向迭代器里面存的是哈希表地址。

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

	template<class K,class T,class Hash,class KeyOfT>
	struct __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, Hash, KeyOfT> Self;
		typedef HashTable<K, T, Hash, KeyOfT> HT;
        
		Node* _node;
		HT* _ht;

	__HTIterator(Node*node,HT*ht)  //构造迭代器需要知道哈希表和节点的地址
			:_node(node)
			,_ht(ht)
		{}


    }

++运算符重载的实现：如果当前的桶还有节点，那么++就是当前桶下一个节点，如果当前元素是所在的桶的最后一个元素，那么++就是下一个非空的桶了。如何寻找下一个非空的桶：首先通过当前节点的值算出当前桶的hashi，然后++hashi就是下一个桶了，如果下一个桶为空桶，那就一直找直到找到下一个非空桶。

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

		bool operator !=(const Self& s) const
		{
			return _node != s._node;
		}
		Self& operator++()
		{
			if (_node->_next)  //访问当前桶中的元素
			{
				_node = _node->_next;
			}
			else   //开始寻找下一个非空桶
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _ht->_tables.size();
				++hashi;
				while (hashi < _ht->_tables.size())
				{
					if (_ht->_tables[hashi])//非空桶

					{
						_node = _ht->_tables[hashi];
						break;
					}
					else
					{
						++hashi;
					}
				}
				if (hashi == _ht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
	};

5.重载[ ]

要想实现[]，我们需要先把Insert的返回值修改成pair<iterator,bool>,最后的返回值也要一起修改

如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器

  如果 key 不存在，插入成功， insert 函数返回新插入元素所在位置的迭代器 
		pair<iterator, bool> Insert(const T&data)
		{
			KeyOfT kot;
			iterator it = Find(kot(data));
			if (it != end())
			{
				return make_pair(it, false);
			}
			if (_tables.size() == _n)
			{
				vector<Node*> newTables;
				newTables.resize(__stl_next_prime(_tables.size()), nullptr);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = Hash()(kot(cur->_data))% newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}
			size_t hashi = Hash()(kot(data)) % _tables.size();
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return make_pair(iterator(newnode,this),true);
		}

6.unordered_set

#pragma once

#include "HashTable.h"

namespace cyf
{
	template<class K,class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename buckethash::HashTable<K, K, Hash, SetKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		pair<iterator, bool> insert(const K& key)
		{
			return _ht.Insert(key);
		}
	private: 
		buckethash::HashTable<K, K, Hash, SetKeyOfT> _ht;
	};


	
}

7.unordered_map

#pragma once

#include "HashTable.h"
namespace cyf
{
	template<class K,class V,class Hash=HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename buckethash::HashTable<K, pair<const K, V>, Hash, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}

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

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		buckethash::HashTable<K, pair<const K, V>, Hash, MapKeyOfT> _ht;
	};


}

8.HashTable.h

#pragma once

#include <iostream>
#include <string>
#include <vector>
using namespace std;

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}
		return hash;
	}
};



namespace buckethash
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

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

	template<class K,class T,class Hash,class KeyOfT>
	struct __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, Hash, KeyOfT> Self;
		typedef HashTable<K, T, Hash, KeyOfT> HT;

		Node* _node;
		HT* _ht;

		__HTIterator(Node*node,HT*ht)
			:_node(node)
			,_ht(ht)
		{}

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

		bool operator !=(const Self& s) const
		{
			return _node != s._node;
		}
		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _ht->_tables.size();
				++hashi;
				while (hashi < _ht->_tables.size())
				{
					if (_ht->_tables[hashi])
					{
						_node = _ht->_tables[hashi];
						break;
					}
					else
					{
						++hashi;
					}
				}
				if (hashi == _ht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
	};

	template<class K,class T,class Hash,class KeyOfT>
	class HashTable
	{
		typedef HashNode<T> Node;
		template<class K,class T,class Hash,class KeyOfT>
		friend struct __HTIterator;

	public:
		typedef __HTIterator<K, T, Hash, KeyOfT> iterator;
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return iterator(_tables[i], this);
				}
			}
			return iterator(nullptr, this);
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}



		HashTable()
			:_n(0)
		{
			_tables.resize(__stl_next_prime(0));
		}

		~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 T&data)
		{
			KeyOfT kot;
			iterator it = Find(kot(data));
			if (it != end())
			{
				return make_pair(it, false);
			}
			if (_tables.size() == _n)
			{
				vector<Node*> newTables;
				newTables.resize(__stl_next_prime(_tables.size()), nullptr);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = Hash()(kot(cur->_data))% newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

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

		iterator Find(const K& key)
		{
			KeyOfT kot;
			size_t hashi = Hash()(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur, this);
				}
				else
				{
					cur = cur->_next;
				}
			}
			return end();
		}

		bool Erase(const K& key)
		{
			size_t hashi = Hash()(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _tables[hashi])
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
		inline unsigned long __stl_next_prime(unsigned long n)
		{
			static const int __stl_num_primes = 28;
			static const unsigned long __stl_prime_list[__stl_num_primes] =
			{
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};

			for (int i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];
				}
			}

			return __stl_prime_list[__stl_num_primes - 1];
		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};
}

bite-ccc
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++ 手写 unordered_map 实现
ljy121121的博客
12-23 1053
insert(Key,Value)插入映射 直接通过 [] 查询 虽然写的是泛型，但暂时不知道非整形的类型要怎么获取hash数，回头学下 #include<iostream> #include<string> using namespace std; #ifndef UNORDEREDMAP #define UNORDEREDMAP template<typename Key, typename Value> class hashNode { public: Key k
C++ 自己实现一个unordered_map(hashmap)
hanzhen7541的博客
04-25 2244
今天面试的时候遇到面试官出了一个问题，要实现一个unordered_map. 我实现的不太好，所以面试之后重新自己整理实现了一个unordered_map，在此记录一下。 首先unordered_map的底层实现是哈希表。那么对于任何一个关键key的哈希，首先需要考虑的是哈希冲突的问题，在这里应该用链表的方式解决。如果不同的key哈希成了同一个地址，那么在链表的基础上向后连接就行。然后主要实现的...
【C++】哈希表封装实现 unordered_map 和 unordered_set
在平淡的日子里寻找存在的价值
04-07 681
unordered_map 和 unordered_set 的使用以及使用哈希表封装实现 unordered_map 和 unordered_set。
【C++】unordered_map和unordered_set的模拟实现
ermu的博客
05-16 344
unordered_map和unordered_set的基础功能模拟实现
C++语法（23）-- 模拟实现unordered_set和unordered_map
竹杖芒鞋轻声马
06-04 536
模拟实现unordered_set和unordered_map
c++ map与unordered_map区别及使用
热门推荐
别说话写代码的博客
12-01 26万+
转自：https://blog.csdn.net/BillCYJ/article/details/78985895 需要引入的头文件不同 map: #include &lt; map &gt; unordered_map: #include &lt; unordered_map &gt; 内部实现机理不同 map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二...
C++ 模拟实现unordered_map&set
Han同学
02-28 992
哈希表封装unordered_map&set
TongXunLu.rar_c++ 通讯录_数据结构_通讯录
09-20
C++是一种强大的、通用的编程语言，特别适合用于系统级编程和高性能计算，包括数据结构的设计和实现。 通讯录是一个常见的应用，其核心功能是存储和管理联系人的信息，如姓名、电话号码、电子邮件地址等。在设计...
STL.rar_c++ 容器使用
09-24
4. **映射容器(如Unordered_Set、Unordered_Map、Unordered_Multiset、Unordered_Multimap)**：这些容器使用哈希表实现，提供近乎常数时间的插入和查找操作，但元素的顺序不确定。 5. **栈(Stack)**：栈是一种后进...
b.zip_library management_图书管理c++
09-22
在C++中，这些数据结构可以通过标准模板库（STL）轻松实现，例如`std::vector`（动态数组）、`std::list`（双向链表）、`std::stack`、`std::queue`、`std::set`（二叉搜索树实现）和`std::unordered_map`（哈希表）...
STL-70个算法.rar_C++_stl 练习
09-23
STL提供了一些核心的数据结构，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的键值对映射）和unordered_set/unordered_map（哈希表实现的集合和映射）。...
数据结构算法总结_C++_orangejj4_
10-02
C++标准库的`std::unordered_map`和`std::unordered_set`实现了哈希表。 7. **二叉树（Binary Tree）**：二叉树每个节点最多有两个子节点，分为二叉搜索树（BST）、平衡树（AVL、红黑树）等。二叉树的操作包括插入...
＜unordered_set、unordered_map的模拟实现＞——《C++高阶》
m0_57859086的博客
09-14 671
unordered_set、unordered_map的结构分析以及模拟实现
C++ 继承篇
2301_79201049的博客
07-18 675
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 175
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 368
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C语言动态内存管理
m0_62183318的博客
07-22 674
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
C++ 红黑树
最新发布
wxk2227814847的博客
07-22 641
在之前的文章中，我们介绍了 C++ 标准库中的 map 和 set 容器的使用，以及 AVL 树的实现。尽管 AVL 树在平衡性方面表现优异，但在插入和删除操作频繁的应用中，红黑树（Red-Black Tree）由于其较少的旋转操作次数，往往能提供更优的性能。本篇博客将详细介绍红黑树的概念、性质、节点定义、结构、插入与删除操作、性能、迭代器设计，并展示基于红黑树的模拟实现代码及其在 map 容器中的应用。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 9273
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
c++哈希表unordered_set unordered_map
10-12
unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联容器，其中的元素是键值对，每个键只能出现一次。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bite-ccc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值