【C++进阶】用哈希实现unordered_set和unordered_map的模拟

最新推荐文章于 2024-06-12 18:28:23 发布
最新推荐文章于 2024-06-12 18:28:23 发布
阅读量778 收藏 17
点赞数 35
分类专栏： c++大冒险 邪王真眼大战数据结构 文章标签： 哈希算法 c++ 算法 开发语言 散列表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79551553/article/details/137503274
版权

🪐🪐🪐欢迎来到程序员餐厅💫💫💫

          主厨：邪王真眼

主厨的主页：Chef‘s blog  

所属专栏：c++大冒险
 

总有光环在陨落，总有新星在闪烁

前言：

        之前我们学完红黑树后对他进行了改造，使之成为map和set的底层容器，今天我们则要把哈希表进行修改并以此为基础实现unordered_set和unordered_map

一.哈希桶（修改版）

1.1.节点

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

注意事项：

  • 数据类型是T，因为要同时适用unordered_set（存储键值）和unordered_map（存储键值对）

类比咱们用红黑树写map和set时的做法。

1.2.迭代器

哈希表的迭代器类型是单向迭代器，没有反向迭代器

1.2.1成员变量

template<class K, class T, class KeyOfT, class HF>
class HashTable;
template<class K,class T, class Ref,class Ptr,class KeyOfT, class HF>
struct HashIterator
{
	typedef HashNode<T> Node;
	typedef HashIterator<K, T, Ref, Ptr, KeyOfT, HF> self;
	typedef HashIterator<K, T, T&, T*, KeyOfT, HF> iterator;
	typedef HashTable<K, T, KeyOfT, HF> HT;
	Node* _node;
	HT* _ht;
};

注意事项：

  •  增加了_ht成员变量，因为在重载++时，当一条单链表走到空，则需要走到下一个哈希桶的位置，需要通过哈希表的vector成员找下一个位置 
  • 因为HashTable是在后面实现的，所以我们要先写一个声明

1.2.2简单函数实现

HashIterator(Node*&node=nullptr,Node*&ht=nullptr)
	:_node(node)
	,_ht(ht)
{}
HashIterator(const iterator&it)
	:_node(it._node)
	, _ht(it._ht)
{}
Ref& operator*()const
{
	return _node->_data;
}
Ptr& operator->()const
{
	return &(_node->_data);
}
bool operator==(const self&se)
{
	return _node == se._node;
}
bool operator!=(const self& se)
{
	return _node != se._node;
}

注意事项：

  • 拷贝构造函数可以以普通迭代器拷贝出普通迭代器（普通迭代器调用时）以及const迭代器（const迭代器调用时）

1.2.3operator++

self& operator++()
{
	Node* node = _node;
	if (node->_next)
	{
		_node = node->_next;
		return *this;
	}
	else
	{
		KeyOfT kot;
		size_t hash = HF(kot(_node->_data)) % _ht->_tables.size()+1;
		for (hash; hash < _ht->_tables.size(); hash++)
		{
			if (_ht->tables[hash])
			{
				_node = _ht->tables[hash];
				return *this;
			}

		}
		_node = nullptr;
		return *this;
	}
}
self operator++(int)
{
	self new_self=*this;
	(*this)++;
	return new_self;
}

思路：

  1. 前置++的思路： 
    1. 下一个结点不为空，则跳到下一位
    2. 下一个结点为空，则先取模算出哈希地址，再往后探测不为空的哈希桶 
  2. 后置++：复用前置++，返回临时对象

1.3哈希桶本身

1.3.1成员变量

template<class K, class T, class KeyOfT, class HF>
class HashTable
{
	template<class K, class T, class Ref, class Ptr, class KeyOfT, class HF>
	friend struct HashIterator;
	typedef HashNode<T> Node;
public:
protected:
	vector<Node*> _tables;
	size_t _size = 0;//有效数据个数
};

注意事项：

  1. 迭代器要访问哈希桶的私有成员，所以要声明友元
  2. 模板参数KeyOfT是为了从类型T中取出键值
  3. 模板参数HF即是HashFunc，哈希函数，用于辅助键值转化为整型进行取模操作

1.3.2构造函数和析构函数

HashTable(size_t size = 10)
{
	_tables.resize(size);
}
~HashTable()
{
	for (auto hash_node : _tables)
	{
		while (hash_node)
		{
			Node* new_node = hash_node->_next;
			delete hash_node;
			hash_node = new_node;
		}
	}
}

1.3.3 begin和end 

typedef HashIterator< K,T, T&, T*,  KeyOfT,  HF> iterator;
typedef HashIterator< K, T, const T&, const T*,  KeyOfT,  HF> const_iterator;
iterator begin()
{
	for (size_t i = 0; i < _tables.size(); i++)
		if (_tables[i])
			return iterator(_tables[i], this);
	return iterator(nullptr, this);
}
const_iterator begin()const
{
	for (size_t i = 0; i < _tables.size(); i++)
		if (_tables[i])
			return const_iterator(_tables[i], this);
	return const_iterator(nullptr, this);
}
iterator end()
{
	return iterator(nullptr, this);
}
const_iterator end()
{
	return const_iterator(nullptr, this);
}

注意事项：

  1. begin返回最开始不为空的哈希桶的迭代器，而不是最开始的哈希桶的迭代器
  2. end返回空迭代器
  3. 构造迭代器需要传入哈希表本身的地址，这里直接传this指针即可

1.3.4Find函数 

iterator Find(const K&key)
{
	HF hf;
	KeyOfT kot;
	size_t hash = hf(key) % _tables.size();
	Node* cur = _tables[hash];
	while (cur)
	{
		if (kot(cur->_data) == key)
			return iterator(cur,_tables);
		cur = cur->_next;
	}
	return iterator(nullptr,_tables);
}

注意事项：

  1. 返回值类型是迭代器
  2. 运用两个仿函数，，kot负责获取存储的键值，hf作为哈希函数把键值key转整型

1.3.5   Insert函数 

	pair<iterator,bool> Insert(T& data)
{
	KeyOfT kot;
	HF hf;
	iterator it = Find(kot(data));
	if (it._node)
	{
		return make_pair(it, false);
	}
	if (_size == _tables.size())
	{
		vector<Node*> new_tables(_size * 2);
		for (auto node : _tables)
		{
			while (node)
			{
				Node* next = node->_next;
				size_t hash = hf(kot(node->_data)) % new_tables.size();
				node->_next = new_tables[hash];
				new_tables[hash] = node;
				node = next;
			}
		}
		_tables.swap(new_tables);
	}
	
	size_t hash = hf(kot(data)) % _tables.size();
	Node* cur = _tables[hash];
	Node* p(data);
	p->_next = cur;
	_tables[hash] = p;
	_size++;
	return make_pair(iterator(p,this),true);
}

注意事项：

  1. 返回值类型是pair，第一个参数为迭代器，第二个参数为布尔值（记录是否插入成功）
  2. 运用两个仿函数，，kot负责获取存储的键值，hf作为哈希函数把键值key转整型

1.3.6Erase函数 

	bool Erase(const K& key)
{
	HF hf;
	KeyOfT kot;
	size_t hash = hf(key) % _tables.size();
	Node* cur = _tables[hash];
	Node* pre = nullptr;
	while (cur)
	{
		if (kot(cur->data) == key)
			break;
		pre = cur;
		cur = cur->_next;
	}
	if (cur == nullptr)
		return false;
	_size--;
	if (pre == nullptr)
		_tables[hash] = cur->_next;
	else
		pre->_next = cur->_next;
	delete cur;
	return true;
}

二、unordered_set

2.1成员变量及仿函数 

template<class K,class HF=HashFunc<K>>
class unordered_set
{
public:
	struct SetKeyOfT
	{
		K& operator()(const K& key)
		{
			return key;
		}
	};
protected:
	HashTable<K, K, SetKeyOfT, HF> _hf;
};

注意事项：

  •  1.这里的数据存储类型就是键值Key本身，所以SetKeyOfT直接返回key就行
  • 2.哈希函数不是固定的，可以根据需求自己进行实现并传到给定模板参数中

2.2 begin和end 

typedef typename HashTable<K, K, SetKeyOfT, HF>::iterator iterator;
typedef typename HashTable<K, K, SetKeyOfT, HF>::const_iterator const_iterator;
iterator begin()
{
	return _ht.begin();
}
const_iterator begin()const
{
	return _ht.begin();
}
iterator end()
{
	return _ht.end();
}
const_iterator end()const
{
	return _ht.end();
}

注意事项：

  • 在C++中，编译器默认iterator为变量名，如果作为类型名，需要在前面加上typename加上typename关键字。
  • unordered_set中存储的键值key不允许修改，所以其普通迭代器和const迭代器均为哈希表的const迭代器
  • 我们称set的begin为A，哈希的begin为B，A的实现是对B的调用，在A的参数是普通迭代器时，B也是普通迭代器，B的返回值也是普通迭代器，但A的返回值是const迭代器，所以这里需要用普通迭代器创建一个const迭代器的临时变量，这就用到之前写的拷贝构造函数了。

2.3Find 

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== 
iterator Find(const K&key)
{
	return _ht.Find(key);
}

注意事项： 

  •  此时也有从普通迭代器到const迭代器的转换 

2.4Insert

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

注意事项： 

  1. 函数形参类型是K
  2. 此时也有从普通迭代器到const迭代器的转换

 2.5Erase

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

三、unordered_map

unordered_map和unordered_set的实现有众多相似之处，

3.1 成员变量与仿函数

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

注意事项：

  • 1.这里节点存的数据类型是pair<K,V>,我们的MapKeyOfT作用是返回其中的键值key 
  • 2.哈希函数不是固定的，可以根据需求自己进行实现并传到给定模板参数中

3.2 begin和end

typedef typename HashTable<K, pair<K,V>, MapKeyOfT, HF>::iterator iterator;
typedef typename HashTable<K, pair<K,V>, MapKeyOfT, HF>::const_iterator const_iterator;
iterator begin()
{
	return _ht.begin();
}
const_iterator begin()const
{
	return _ht.begin();
}
iterator end()
{
	return _ht.end();
}
const_iterator end()const
{
	return _ht.end();
}

注意事项：

  1. 加上typename关键字，编译器才能识别类型
  2. unordered_map不允许修改key，故普通迭代器和const的pair中的K都要加上const修饰，但是允许修改存储的data，所以普通和const迭代器一一对应(好好想想这点map和set的处理差异)

3.3 find

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

3.4Insert

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

注意事项：

  • 形参类型是键值对而不是键值

3.5 operator[ ]

V& operator[](const& K key)
{
	return (*(_ht.Insert(make_pair(key, V()))).first).second;
}
//或者你也可以这么写
V& operator[](const K& key)
{
	pair<iterator, bool> cur = insert(make_pair(key, V()));
	return cur.first->second;
}

注意事项：

  1.  利用operator[]进行插入和修改操作是很方便的，所以要学会灵活运用哦 
  2. 返回值是value的引用，我们可以直接进行修改 

3.6 Erase 

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

 

 如果你对该系列文章有兴趣的话不妨点个关注哦，我会持续更新相关博客的

🥰创作不易，你的支持对我最大的鼓励🥰

🪐~ 点赞收藏＋关注 ~🪐

 

一颗青果
关注
  • 35
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
模拟实现unordered_map和unordered_set超详解（C++）
m0_67430750的博客
05-19 2147
模拟实现unordered_map、unordered_set超详解，包括哈希表以及unordered_map、unordered_set完整代码，迭代器封装、功能测试等。
unordered_set/map（哈希表）干货归纳+用法详解
lzq8090的博客
03-27 3341
C++哈希表（hash table）是一种数据结构，用于存储和查找键值对。它是由一个哈希函数和一个数组组成的。哈希函数将键映射到数组中的一个位置，这个位置就是键值对应的索引。
小心使用指针当做 unordered_set / unordered_map 的键
weixin_36888577的博客
04-04 2466
当我们试图使用指针作为哈希的键时, 要小心下面的情况: #include <set> #include <map> #include <vector> #include <memory> #include <utility> #include <iostream> #include <unordered_set> ...
【C++】unordered_map和unordered_set
Zhuang_N的博客
10-06 445
【C++】unordered_set和unordered_map的简单介绍，以及解决哈希冲突的两种方法，用哈希桶简单实现unordered_set和unordered_map
C++11:关联式容器：unordered_set
qq_59535638的博客
06-08 1767
unoredered_set特性，常用接口的使用
C++进阶之哈希（unordered_map/set的使用及其模拟）
yin_ming_hui的博客
08-03 808
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(N)，搜索的效率取决于搜索过程中元素的比较次数理想的搜索方法是可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素，则复杂度为O(1)非常的高效，而计数排序用的即是这种思想。......
unordered_flat_set:C ++连续内存哈希容器。-开源
04-25
连续内存开放式寻址/封闭式散列，带有线性探测，容器。 基本上是unordered_set，unordered_map，unordered_multiset和unordered_multimap，但具有类似内存分配的向量。
算法（42）-数组等值切割-前缀累加和-哈希表Map-set版-C++
01-07
题目：给定正整数，返回该数组能不能分成4... set和map两种哈希表类型。其实没啥本质差别。 1.unordered_set版   bool canSplits_set(vci arr) { if (arr.size() < 7) { return false; } unordered_set m
sparsepp:用于 C++ 的快速、内存高效的哈希映射
05-29
unordered_map 和 unordered_set 的替代方案。 极低的内存使用量（通常每个条目大约一个字节的开销），最重要的是调整大小时非常小的内存开销。 非常高效，通常比编译器的无序映射/集或 Boost 更快。 C++11 支持...
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
parallel-hashmap:一系列仅标头，非常快速且对内存友好的hashmap和btree容器
04-28
该存储库旨在提供一组出色的哈希映射实现，以及std :: map和std :: set的btree替代品，具有以下特征： 仅标头：无需构建，只需将parallel_hashmap目录复制到您的项目中就可以了。 替换std::unordered_map ， std::...
C++ 11中unordered_set和unordered_map简单介绍和运用
小雨的分享斋
02-07 4052
C++STL中的hash数据结构 ——unordered_set 参考链接 leetcode题目推荐 用于存放hash散列，其搜索插入移除通常为常数时间，其原理是声明一个有n个桶的数据结构 特点： unordered_set为一种容器，以不特定的顺序存储唯一元素，可根据值检索 unordered_set中，元素的值同时事唯一标识它的键，键不可变，只可以增删。 在内部，unordered_set中的元素没有按照任何特定的顺序排序，而是根据它们的散列值组织成桶（一个线性链表代表一个桶），从而允许通过它们的值直
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 989
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 140
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 670
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1233
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 297
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
c++哈希表unordered_set unordered_map
10-12
unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联容器，其中的元素是键值对，每个键只能出现一次。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值