C++——哈希2|哈希封装

最新推荐文章于 2024-08-29 18:01:01 发布
最新推荐文章于 2024-08-29 18:01:01 发布
阅读量968 收藏 7
点赞数 7
分类专栏： C++ 文章标签： 哈希算法 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49449676/article/details/127904455
版权

目录

基本封装 

迭代器的实现 

begin和end 

 HashTable.h

unordered_map.h 

unordered_set.h 

 

基本封装 

通过哈希实现unorderedmap和unorderedset,我们把哈希表模板参数这里改为T，哈希表第二个的模板参数对于Map是pair，对于Set是K。

这块的仿函数也去掉，套在上一层

 

加上KeyOfT

接下来把之前写的哈希表里取值的地方都改一遍 

unorderedmap.h

#include"HashTable.h"
namespace myspace
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		bool Insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}
	private:
		Bucket::HashTable<K, pair<K, V>,Hash, MapKeyOfT> _ht;
	};
}

unorderedset.h

#include"HashTable.h"
namespace myspace	
{
	template <class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& kv)
			{
				return kv.first;
			}
		};
	public:
		bool Insert(const K& key)
		{
			return _ht.Insert(key);
		}
		private:
			Bucket::HashTable<K, K,Hash,SetKeyOfT> _ht;
	};
}

迭代器的实现 

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

		template<class K, class T, class Hash, class KeyOfT>
		struct __HashIterator
		{
			typedef HashNode<T> Node;
			typedef HashTable<K, T, Hash, KeyOfT> HT;
			typedef __HashIterator<K, T, Hash, KeyOfT> Self;
			Node* _node; //节点的指针
			HT* _pht;//哈希表的指针
			HashTable(Node *node,HT *pht)
				:_node(node)
				,_pht(pht)
			{

			}
			T& operator* ()
			{
				return _node->_data;
			}
			T* operator->()
			{
				return &_node->_data;
			}
			Self& operator++()
			{
				if (_node->_next)
				{
					// 当前桶中迭代
					_node = _node->_next;
				}
				//如果当前桶已经走完，则进入下一个桶
				else
				{
					// 找下一个桶
					Hash hash;
					KeyOfT kot;
					size_t i = hash(kot(_node->_data)) % _pht->_tables.size();//计算当前在那个桶，先取出节点里面data的K取出来，然后把K转成size_t
					++i;//当前桶已经走完了，++i往下一个桶走
					for (; i < _pht->_tables.size(); ++i)
					{
						if (_pht->_tables[i])//如果桶不为空，让_node指向这个桶，为空则++i，跳过该桶
						{
							_node = _pht->_tables[i];
							break;
						}
					}

					// 说明后面没有有数据的桶了
					if (i == _pht->_tables.size())//走到最后一个桶了
					{
						_node = nullptr;
					}
				}

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

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

begin和end 

	typedef __HashIterator<K, T,Hash,KeyOfT> iterator;
			iterator begin()
			{
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					if (_tables[i])
					{
						return iterator(_tables[i], this);//this是哈希表指针
					}
				}

				return end();//一个桶都没有
			}

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

对于map要使用[]，需要修改Insert ，如果新插入，就使用新插入节点构造的迭代器

 

 unorderedmap测试

void test_map()
	{
		unordered_map<string, string> dict;
		dict.Insert(make_pair("sort", ""));
		dict.Insert(make_pair("string", "ַ"));
		dict.Insert(make_pair("left", ""));

		unordered_map<string, string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;

		unordered_map<string, int> countMap;
		string arr[] = { "ƻ", "", "ƻ", "", "ƻ", "ƻ", "", "ƻ", "㽶", "ƻ", "㽶" };
		for (auto e : arr)
		{
			countMap[e]++;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}
}

 上图出现2是汉字

 

  我们在比较数据的时候把这里直接写成了==，这种写法有问题，若是Date*的俩个变量做比较，则比不出来

 源代码中有一个仿函数，可以解决这种问题。

一个类型K去做Set或unordered_set的模板参数，有什么要求？

 set要求能比较大小，要求支持小于比较，比较的时候换一下参数顺序即可。如果不支持比较大小，显示提供比较的仿函数即可

unordered_set：K类型对象可以转换成整形取模或者 支持提供转成整形的仿函数

                            K类型对象可以支持等于比较或者提供等于比较的仿函数

 HashTable.h

namespace Bucket
{
	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 __HashIterator
	{
		typedef HashNode<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> HT;
		typedef __HashIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		HT* _pht;

		__HashIterator(Node* node, HT* pht)
			:_node(node)
			, _pht(pht)
		{}

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

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

		Self& operator++()
		{
			if (_node->_next)
			{
				// 当前桶中迭代
				_node = _node->_next;
			}
			else
			{
				// 找下一个桶
				Hash hash;
				KeyOfT kot;
				size_t i = hash(kot(_node->_data)) % _pht->_tables.size();
				++i;
				for (; i < _pht->_tables.size(); ++i)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						break;
					}
				}

				// 说明后面没有有数据的桶了
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}

			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 Hash, class KeyOfT>
	class HashTable
	{
		typedef HashNode<T> Node;

		template<class K, class T, class Hash, class KeyOfT>
		friend struct __HashIterator;
	public:
		typedef __HashIterator<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 end();
		}

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

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

		inline size_t __stl_next_prime(size_t n)
		{
			static const size_t __stl_num_primes = 28;
			static const size_t __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 (size_t i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];
				}
			}

			return -1;
		}

		pair<iterator, bool> Insert(const T& data)
		{
			Hash hash;
			KeyOfT kot;

			// 去重
			iterator ret = Find(kot(data));
			if (ret != end())
			{
				return make_pair(ret, false);
			}

			// 负载因子到1就扩容
			if (_size == _tables.size())
			{
				//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTables;
				//newTables.resize(newSize, nullptr);
				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;
			++_size;

			return make_pair(iterator(newnode, this), true);
		}

		iterator Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return end();
			}

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			return end();
		}

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					// 1、头删
					// 2、中间删
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;
					--_size;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

		size_t Size()
		{
			return _size;
		}

		// 表的长度
		size_t TablesSize()
		{
			return _tables.size();
		}

		// 桶的个数
		size_t BucketNum()
		{
			size_t num = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i])
				{
					++num;
				}
			}

			return num;
		}

		size_t MaxBucketLenth()
		{
			size_t maxLen = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				size_t len = 0; 
				Node* cur = _tables[i];
				while (cur)
				{
					++len;
					cur = cur->_next;
				}

				//if (len > 0)
					//printf("[%d]号桶长度:%d\n", i, len);

				if (len > maxLen)
				{
					maxLen = len;
				}
			}

			return maxLen;
		}

	private:
		vector<Node*> _tables;
		size_t _size = 0; // 存储有效数据个数
	};

unordered_map.h 

#include "HashTable.h"

namespace myspace
{
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename Bucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;

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

		iterator end()
		{
			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:
		Bucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	};

unordered_set.h 

#include "HashTable.h"

namespace myspace
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename Bucket::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:
		Bucket::HashTable<K, K, Hash, SetKeyOfT> _ht;
	};

头发没有代码多
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
c++——哈希
蜗@牛的博客
07-15 2182
概念 哈希是一种搜索数据结构，不过哈希搜索不同于顺序搜索和二叉搜索的是：哈希可以不经过任何比较，一次直接从表中得到要搜索的元素。它是通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数就可以直接找到该元素。 哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表 (Hash Table)(或者称散列表) 。 哈希冲突 哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间的大小。
C++哈希
qq_53413129的博客
06-09 3615
unordered系列关联式容器 unordered_map unordered_map的文档介绍 unordered_set 底层结构 哈希概念 哈希冲突的解决 闭散列： 代码实现 哈希基本结构 插入 查找find 删除 仿函数的应用 开散列 基本结构 插入的实现 查找 删除 Unordered_set/Unordered_set对哈希的封装 封装代码框架： 哈希表的迭代器 【operator*和operator->】 operator++前置++ 迭代器
c++ 封装哈希表（Hash） 以及实现迭代器（iterator）
sumkee911‘s coding
12-16 3567
程序功能: 1.封装哈希表(Hash) 2.以及实现了迭代器(iterator) 3.允许string类，整形变量，浮点形变量，字符型变量等作为key值 废话不多说，马上上源码 Hash.h /* * Name: Hash * Date: 14-12-2015 * Author: Sumkee * Brief: 哈希模组 * 1.能把strin
C++ STL begin()和end()函数(深入了解,一文学会)
热门推荐
断点
09-04 1万+
C++ STL标准库提供的所有容器做了系统的讲解。无论是序列式容器还是关联式容器（包括哈希容器），不仅模板类内部提供有 begin() 和 end() 成员方法，C++ STL 标准库中还提供有同名且具有相同功能的begin() 和 end() 函数。 首先需要说明的是，begin() 和 end() 是以函数模板的形式定义的，但它们的模板并没有位于某一个头文件中，而是很多头文件中都有它们的定义。 C++ STL 标准库中，包含 begin() 和 end() 函数模板的头文件包括：...
C++进阶——哈希的实现
weixin_43635473的博客
05-30 1032
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到O(log2​N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。
哈希表封装实现 unordered_map 和 unordered_set——哈希表の华丽二重奏
qq_61500888的博客
10-04 1958
带你一命通关 unordered_map 和 unordered_set 底层 十分钟手撕数据结构原理
【C++】哈希
qq_66314292的博客
03-01 1460
哈希原理，哈希底层实现，哈希封装
C++ 哈希
m0_61548909的博客
08-27 2808
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
中级C++：哈希
FamerSaul的博客
06-29 467
闭散列、闭散列、封装成unorder_map、unorder_set
【数据结构】—— 树和二叉树
mist的博客
08-26 1276
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 647
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1496
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 872
浅谈【数据结构】树与二叉树之哈夫曼树
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 580
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1129
KMP算法：理解next[]表
集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
2301_79418684的博客
08-26 823
哈希表、字符串常量池和练习题 1. 哈希表的概念 2. 冲突-概念 3. 冲突-避免 4. 冲突-解决 5. 冲突严重时的解决办法 6. 冲突严重时的解决办法的实现 7. 性能分析 8. 和 java 类集的关系 9. Hashmap的使用案例 10. 模拟实现HashMap（k-v模型） 11. 创建对象的思考 12. 字符串常量池(StringTable) 13. 再谈String对象创建 14. 练习
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1053
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
浅谈【数据结构】树与二叉树之平衡二叉树
weixin_67526434的博客
08-26 302
浅谈【数据结构】树与二叉树之平衡二叉树
c++ 哈希表map
08-16
- *1* *2* *3* [【C++】通过哈希表实现map和set](https://blog.csdn.net/weixin_61508423/article/details/128043581)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

头发没有代码多

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

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

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

打赏作者

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

抵扣说明：

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

余额充值