C++进阶-哈希封装（unordered_set和unordered_set）

于 2024-07-30 18:33:13 发布
阅读量362 收藏 3
点赞数 4
分类专栏： C++进阶 文章标签： c++ 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64423718/article/details/140802666
版权

1. 哈希封装思路

首先，内层用的是哈希表，哈希表使用泛型编程，外层unordered_map和unordered_set给与相应的参数，之后编译器自动生成。

2. 哈希封装的模拟实现

主要由三个头文件进行封装，My_unordered_map.h，My_unordered_set.h和HashTable.h头文件，分别装有My_unordered_map，My_unordered_set，哈希表。

2.1 HashTable.h

除留取余法的仿函数，让数据类型转换为可以取余的类型

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

// 特化
template<>
struct HashFunc<string>
{
	// abcd
	// bcad
	// aadd
	// BKDR
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}

		return hash;
	}
};

2.1.1 节点数据类

用来初始化节点，定义节点数据

// 节点数据
template<class T>
struct HashNode
{
	T _data;// 节点数据
	HashNode<T>* _next;// 下一个节点地址

	// 构造函数
	HashNode(const T& data)
		:_data(data),
		_next(nullptr)
	{}
};

2.1.2 迭代器类

operator++()

  1. 节点是这个表索引位置下的最后一个节点
    a.找下一个不为空的数组索引的指针，找到
    b.没找到，直接置空
    在这里插入图片描述

  2. 节点不是表索引的位置下的最后一个节点，直接找下一个节点

// ++
	// 如果当前节点是这个表的_tables[i]的最后一个节点，++需要找到数组的下一个索引
	// 所以需要引入表，才可以找到下一个位置
	// 1.节点是这个表索引位置下的最后一个节点
	//​	a.找下一个不为空的数组索引的指针，找到
	//	​b.没找到，直接置空
	// 2.节点不是表索引的位置下的最后一个节点，直接找下一个节点
	Self& operator++()
	{
		// 2.节点不是表索引的位置下的最后一个节点，直接找下一个节点
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else// 1.节点是这个表索引位置下的最后一个节点
		{
			Hash hs;
			KeyOfT kot;
			// 首先找到这个表上当前节点的索引位置
			size_t i = hs(kot(_node->_data)) % _pht->_tables.size();

			++i;
			// 寻找这个表上下一个指向不为空的索引下的指针
			for (; i < _pht->_tables.size(); i++)
			{
				// 如果不为空，则就找到了
				if (_pht->_tables[i])
				{
					break;
				}
			}

			// 如果遍历完表也没找到指向不为空的索引指针
			if (i == _pht->_tables.size())
			{
				_node = nullptr;
			}
			else
			{
				_node = _pht->_tables[i];// _node指向这个索引位置下指针指向的第一个节点
			}

		}

		return *this;
	}

由于如果当前节点是当前索引的最后一个节点时，则要找下一个指向不为空的索引指针，所以要获取当前表。所以成员会引入
const HashTable<K, T, KeyOfT, Hash> _pht;// 引用一个表的指针*
但是哈希表中也会引入迭代器，所以两两形式互相依赖，所以需要在迭代器类的前面进行哈希表类的声明


// 由于__HTIterator类和HashTable互相依赖，__HTIterator中引入表的成员变量，HashTable也引入了迭代器
// 两两互相依赖
// 由于__HTIterator先定义的，得HashTable类在前面声明，否则无法找到HashTable
template<class K, class T, class KeyOfT, class Hash>
class HashTable;

迭代器类的总体代码

// 哈希桶的迭代器
//        data														T&          T*
template<class K,class T,  class KeyOfT, class Hash, class Ref, class Ptr>
struct __HTIterator
{
public:
	// 重定义节点数据
	typedef HashNode<T> Node;

	// 重定义迭代器数据
	typedef __HTIterator<K, T, KeyOfT, Hash, Ref,Ptr> Self;

	// 构造函数
	__HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht)
		:_node(node),
		_pht(pht)
	{}

	// 解引用
	// T&
	Ref operator*()
	{
		return _node->_data;
	}

	// 解引用
	// T*
	Ptr operator->()
	{
		return &_node->_data;
	}

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

	// ++
	// 如果当前节点是这个表的_tables[i]的最后一个节点，++需要找到数组的下一个索引
	// 所以需要引入表，才可以找到下一个位置
	// 1.节点是这个表索引位置下的最后一个节点
	//​	a.找下一个不为空的数组索引的指针，找到
	//	​b.没找到，直接置空
	// 2.节点不是表索引的位置下的最后一个节点，直接找下一个节点
	Self& operator++()
	{
		// 2.节点不是表索引的位置下的最后一个节点，直接找下一个节点
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else// 1.节点是这个表索引位置下的最后一个节点
		{
			Hash hs;
			KeyOfT kot;
			// 首先找到这个表上当前节点的索引位置
			size_t i = hs(kot(_node->_data)) % _pht->_tables.size();

			++i;
			// 寻找这个表上下一个指向不为空的索引下的指针
			for (; i < _pht->_tables.size(); i++)
			{
				// 如果不为空，则就找到了
				if (_pht->_tables[i])
				{
					break;
				}
			}

			// 如果遍历完表也没找到指向不为空的索引指针
			if (i == _pht->_tables.size())
			{
				_node = nullptr;
			}
			else
			{
				_node = _pht->_tables[i];// _node指向这个索引位置下指针指向的第一个节点
			}

		}

		return *this;
	}

private:
	Node* _node;// 节点数据
	const HashTable<K, T, KeyOfT, Hash>* _pht;// 引用一个表的指针
};

注意：
由于const迭代器中的begin和end都是const类型函数，const修饰函数的是this本身不能修改，所以迭代器类中的表指针要加上const
在这里插入图片描述

2.1.3 哈希表类

注意：

  1. 迭代器类中的表不能访问到哈希表类中私有成员的_tables，所以让迭代器类成为哈希表类的友元
// 哈希表
//			Key	   Value  转换为可以比较数据的key   哈希强制转换为可取余的值
template< class K, class T, class KeyOfT, class Hash>
class HashTable
{
public:

	// 由于_tables在HashTable类中是私有成员，无法在__HTIterator类被访问
	// 所以将__HTIterator变成HashTable的友元
	template<class K, class T, class KeyOfT, class Hash, class Ref, class Ptr>
	friend struct __HTIterator;

	// 重定义节点
	typedef HashNode<T> Node;

	// 引入普通迭代器
	typedef typename __HTIterator<K, T, KeyOfT, Hash, T&, T*> Iterator;

	// 引入const迭代器
	typedef typename __HTIterator<K, T, KeyOfT, Hash, const T&,const T*> Const_Iterator;


	// Begin()
	// 找到第一个指向不为空的索引的指针
	Iterator Begin()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			if (cur)
			{
				return Iterator(cur, this);
			}
		}

		// 没找到
		return Iterator(nullptr, this);
	}

	// End()
	// 直接返回空
	Iterator End()
	{
		return Iterator(nullptr, this);
	}

	// const迭代器
	// Begin()
	// 找到第一个指向不为空的索引的指针
	Const_Iterator Begin() const
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			if (cur)
			{
				return Const_Iterator(cur, this);
			}
		}

		// 没找到
		return Const_Iterator(nullptr, this);
	}

	// End()
	// 直接返回空
	Const_Iterator End() const
	{
		return Const_Iterator(nullptr, this);
	} 
	

	// 构造函数
	HashTable()
	{
		_tables.resize(10, nullptr);// 提前开辟好空间
		_n = 0;
	}

	// 析构函数
	~HashTable()
	{
		// vector的数组有自己的析构函数
		// 我们只有写相应的Node*节点的销毁
		// 遍历整个vector，全部删除节点
		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);
		}
		
		// 扩容
		// 负载因子为1，理想状态下，平均每个桶下面挂一个数据
		Hash hs;// 将数据转换为可取余的数据类型
		
		// 第二种扩容，建立一个Node*数据的数组
		if (_n == _tables.size())
		{
			vector<Node*> newTables(_tables.size() * 2, nullptr);

			for (size_t i = 0; i < _tables.size(); i++)
			{
				// 取旧表中的每一个头节点指针
				Node* cur = _tables[i];

				while (cur)
				{
					// 记录旧表的cur的下一节点位置，cur被移动到新表中时，将下面的节点与数组的指针相连
					Node* next = cur->_next;

					// 头插到新表的位置
					// 先判断旧表数据在新表的哪个位置
					size_t hashi = hs(kot(cur->_data)) % newTables.size();

					// 旧表数据插入到新表中
					cur->_next = newTables[hashi];
					newTables[hashi] = cur;

					cur = next;// 之后将旧表的节点数据向前移动一个
				}

				_tables[i] = nullptr;// 旧表当前节点指针，全部插入到新表完后，将旧表的指针指向空
			}

			// 旧表数据全部插入到新表中后
			// 交换两表的数据
			_tables.swap(newTables);

		}


		// 查找相应的数据存放在数组的相对位置
		size_t hashi = hs(kot(data)) % _tables.size();
		Node* newnode = new Node(data);

		// 头插新节点
		// _tables[hashi]只是一个指针，并不是哨兵位
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;
		++_n;

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

	// 查找
	Iterator Find(const K& key)
	{
		// 运用仿函数对象，才能进行哈希的比较
		Hash hs;
		KeyOfT kot;

		// 查找相应的数据存放在数组的相对位置
		size_t hashi = hs(key) % _tables.size();

		// 数组相应位置的节点数据
		Node* cur = _tables[hashi];

		// 链表查找
		while (cur)
		{
			// 相等，找到了
			if (kot(cur->_data) == key)
			{
				return Iterator(cur, this);
			}
			else// 不相等，则就继续向下查找
			{
				cur = cur->_next;
			}
		}

		// 找完了，没找到
		return Iterator(nullptr, this);

	}


	// 删除
	// 找到相应的key
	bool Erase(const K& key)
	{
		Hash hs;

		// 先找到key在数组中的相应位置
		size_t hashi = hs(key) % _tables.size();

		// 删除节点
		// 提前记录前一节点的指针
		Node* prev = nullptr;
		Node* cur = _tables[hashi];

		while (cur)
		{
			// 如果找到相应的节点时
			if (cur->_kv.first == key)
			{
				// 开始删除
				// 删除头节点
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else// 删除非头节点
				{
					prev->_next = cur->_next;
				}

				delete cur;

				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}

		}

		return false;
	}
private:
	vector<Node*> _tables;
	size_t _n;

	//vector<list<pair<K, V>>> _tables; 不用这种，这种不好套迭代器
};

2.2 My_unordered_map.h

#pragma once
#include"HashTable.h"

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 hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::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);
	}

	// 查找
	iterator Find(const K& key)
	{
		return _ht.Find(key);
	}


	// 删除
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}

	// []运算符重载
	// 返回值为V
	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = Insert(make_pair(key,V()));
		return ret.first->second;// 调用operator->
		
	}

private:
	hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;

};

测试用例

void test_unordered_map()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };
	unordered_map<string, int> countMap;
	for (auto& e : arr)
	{
		countMap[e]++;
	}

	unordered_map<string, int>::iterator it = countMap.begin();
	while (it != countMap.end())
	{
		//it->first += 'x'; // key不能修改
		//it->second += 1;  // value可以修改
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;

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

2.3 My_unordered_set.h

#pragma once
#include"HashTable.h"

template<class K, class Hash = HashFunc<K>>
class unordered_set
{
public:
	// 仿函数
	// 类型不同，转换为可以比较大小的数据
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};

	// 引入普通迭代器
	typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator;

	// const迭代器
	typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Const_Iterator const_iterator;

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

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

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

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


	// 插入
	pair<iterator, bool> Insert(const K& key)
	{
		return _ht.Insert(key);
	}

	// 查找
	iterator Find(const K& key)
	{
		return _ht.Find(key);
	}

	// 删除
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}

private:
	hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;
};


//void Func(const unordered_set<int>& s)
//{
//	unordered_set<int>::iterator it = s.begin();
//	while (it != s.end())
//	{
//		//*it = 1;
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//}

测试用例

void test_unordered_set()
{
	unordered_set<int> s;
	s.Insert(31);
	s.Insert(11);
	s.Insert(5);
	s.Insert(15);
	s.Insert(25);

	unordered_set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		//*it = 1;
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}
bingo691
关注
专栏目录
unordered_set unordered_map的运用
Forbest1的博客
11-26 1425
unordered_set unordered_map的运用
C++进阶：封装unordered_map和unordered_set以及海量数据面试题
碧瑶的博客呀
11-19 443
使用哈希桶对unordered_map和unordered_set进行封装、海量数据面试题（位图的介绍、布隆过滤器、倒排索引）、unordered_map与map的相同和不同
unordered_set使用介绍
TamakiRinko的博客
09-17 1万+
unordered_set C++ 11，新的关联容器：unordered_set 基本介绍 set和map内部实现是基于RB-Tree，而unordered_set和unordered_map内部实现是基于哈希表。 unordered_set 容器类型的模板定义在 <unordered_set> 头文件中。 # include<unordered_set> ...
STL之unordered_set 【无序不重复集合】
最新发布
江天飞鸟的博客
01-24 1545
STL之unordered_set 【无序不重复集合】
C++容器——集合（unordered_set）
shouhu010的博客
03-28 5638
C++ 容器 unordered_set 初始化 元素访问 元素操作
C++哈希容器使用指南unordered_set
大聪明cc的博客
06-27 774
find(key)->返回value在迭代器的位置，若在该容器中未找到该值，则返回指向最后一个元素之后的迭代器；max_size()->返回容器所能容纳元素的最大个数，不同的操作系统，其返回值亦不相同。end()->返回指向容器中最后一个元素之后位置的正向迭代器。begin() ->返回指向容器中第一个元素的正向迭代器;clear()->清空容器，即删除容器中存储的所有元素。insert(value)->向容器中添加新元素;size()->返回当前容器中存有元素的个数;erase()->删除指定元素;
初识C++之unordered_map与unordered_set
Masquerena114514的博客
04-07 2268
本文主要讲述了通过对哈希桶的改造，使得unordered_set和unordered_map能够对同一个哈希桶进行封装并模拟实现
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 873
C++实现哈希表封装unordered_map unordered_set
模拟实现unordered_map和unordered_set超详解（C++）
m0_67430750的博客
05-19 2247
模拟实现unordered_map、unordered_set超详解，包括哈希表以及unordered_map、unordered_set完整代码，迭代器封装、功能测试等。
C++数据结构 —— 哈希表、unordered_map/set封装
weixin_59913110的博客
03-17 1608
顺序结构以及平衡二叉搜索树结构中，在查找一个元素时需要经过比较。顺序查找时间复杂度为O(N)，平衡二叉搜索树查找时间复杂度为O(log_2N)。理想的搜索方法便是不经过任何比较，通过常数次的操作从表中得到搜索的元素。如果构造一种存储结构，如果某种函数使元素的存储位置与它存储的元素之间形成一种映射关系，那么在查找中可以通过该函数很快找到搜索元素。该方式称为哈希(散列)方法，哈希方法使用的转换函数称为哈希函数， 构造出来的数据结构称为哈希表。
力扣C++学习笔记——unordered_set 力扣
耶律大石的博客
11-11 316
即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。用于顺序容器，并且只能在尾部插入元素。它们在避免不必要的拷贝或移动操作方面提供了性能上的好处。是用于在容器中插入元素的成员函数。它们的主要区别取决于容器的类型。unordered_set 容器，可直译为“说明emplace插入数据是插入到开头的。三、unordered_set的初始化。函数都是在容器中就地构造新元素的方法。用于关联容器和无序容器，
C++常用语法——unordered_set
热门推荐
LiuXF93的博客
10-22 2万+
一、使用前提 引入头文件： #include <unordered_set> 二、unordered_set是什么 unordered_set 容器，可直译为“无序 set 容器”。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。 unordered_set的几个特性： 不再以键值对的形式存储数据，而是直接存储数据的值 ； 容器内部存储的各个元素的值都互不相等，且不能被修改； 不会
【C++进阶】八、STL---unordered_set & unordered_set的介绍及使用
枫叶先生的博客
03-15 1992
unordered_set & unordered_set的介绍及使用
【C++】unordered_set 和 unordered_map 使用 | 封装
qq_62939852的博客
05-27 2178
哈希桶HashBucket中需要将其内部的HashNode 的参数进行修改将原来的模板参数 K，V 改为 T同样由于不知道传入数据的是K还是K V类型的 ，所以 使用 T 类型的data代替之前实现的模板参数 K ，V分别代表 key 与value修改后 ， 第一个参数 拿到单独的K类型，是为了 使用 Find erase接口函数的参数为K第二个参数 T 决定了 拿到的是K类型 还是 K V 类型。
unordered_map与unordered_set的用法
肘子的博客
07-20 1751
unordered_set是C++中的哈希，如果想让自定义的class作为key（unordered_set<key,value>）来使用unordered_set，需要实现： (1) 哈希函数，需要实现一个class重载operator()，将自定义class变量映射到一个size_t类型的数。一般常用std::hash模板来实现。 (2) 判断两个自定义class类型的变量是否相等...
unordered_set和unordered_map的使用【STL】
Man9o
11-23 2085
unordered_set是存储键值对的关联式容器，其允许通过key值快速的索引到与其对应的value值；键值key通常用于唯一地标识元素，而value值是一个对象，它的内容和键值key关联；unordered_set没有对按照任何特定的顺序排序，为了能在常数范围内找到key所对应的value，unordered_set将相同哈希值的键值对放在相同的桶中；
【c++STL——第八讲】set系列 (常用知识点总结)
m0_63233163的博客
05-08 6320
大家好，我是quicklysleep，欢迎大家光临我的博客,算法学习笔记系列持续更新中~ 文章目录一、前言二、set的定义三、set的常用函数四、set的遍历方法五、set的自定义排序六、multiset七、unordered_set八、unordered_muliset最后 一、前言 在 C++ 中，set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。 set内部采用的就是一种非常高效的平衡检索二叉
STL无序容器之unordered_set和unordered_multiset
AndyJ的学习之旅
05-07 1798
参考链接 unordered_set unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。 unordered_set 容器具有以下几个特性： 不再以键值对的形式存储数据，而是直接存储数据的值； 容器内部存储的各个元素的值都互不相等，且不能被修改。 不会对内部存储的数据进行排序（这和该容器底层采用哈希表结构存储数据有关） 实现 unordered_set 容器的模板类定义在<unordered_s
unordered_map中.end
09-05
在unordered_map中，.end()函数返回一个指向unordered_map的末尾的迭代器。这个迭代器指向的是哈希桶的末尾，而不是unordered_map中的最后一个元素。具体来说，unordered_map内部使用哈希表来存储键值对，每个桶中存储一个链表或红黑树，用于解决哈希冲突。对于unordered_map而言，每个桶的末尾都有一个指向下一个桶的指针，而.end()函数返回的迭代器指向的就是这个指针。通过与.begin()函数相结合，可以使用迭代器遍历整个unordered_map。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [【C++】unordered_set 和 unordered_map 使用 | 封装](https://blog.csdn.net/qq_62939852/article/details/130896774)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值