【C++】—— 封装底层为哈希表的unordered_map/set

最新推荐文章于 2024-09-08 23:35:46 发布
最新推荐文章于 2024-09-08 23:35:46 发布
阅读量2.9k 收藏 9
点赞数 4
分类专栏： C++学习 文章标签： 哈希桶 unorderedmap/set HashFunc 字符串哈希函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxiyuehh/article/details/90177083
版权

之前介绍了哈希表和解决哈希冲突的两种方式

今天介绍如何封装底层为哈希表的unordered_map/set，这里是以拉链法实现的哈希表作为底层结构构(哈希桶)

哈希表的改造

一、改造HashNode
  • 因为哈希表不仅要给unordered_map 使用还要给unordered_set使用，因此节点中存储的元素可能为键值对pair<K,V>，也可能只是一个值value，因此我们这里存储的值给了一个泛型，若是unordered_map调用就存储键值对pair<K,V>，若是unordered_set就存储值value。
template<class V>
struct HashNode
{
	//由于之后要用哈希桶封装unordered_map/set，因此这里可能存pair<K,V>也可能存value
	V _valuefiled;
	HashNode<V>* _next;//哈希桶结构是一个vector数组下挂着链表，定义一个指针指向下一个节点的位置

	HashNode(const V& v)
		:_valuefiled(v)
		, _next(nullptr)
	{}
};
二、改造哈希表的Insert
  • 第一个就是插入的值不再仅仅只是键值对，而是看是UnorderedMap使用红黑树时，就传pair<K,V>,UnorderedSet使用时就传value
  • 第二个比较关键的改造是在于，比较所存储值的大小，我们知道map中存储的是键值对，比较大小使用键值对中的第一个值key进行比较，而set比较直接就是用该值进行的，因此这里我们就借助了一个仿函数来实现，创建一个仿函数对象，通过该对象的返回值来进行大小的比较
	bool Insert(const V& v)
	{
		//考虑增容
		CheckCapacity();

		KeyOfValue kov;
		const K& key = kov(v);
		//size_t index = key % _table.size();
		size_t index = HashIndex(key, _table.size());

		Node* cur = _table[index];
		while (cur)
		{
			if (kov(cur->_valuefiled) == key)
				return false;
			cur = cur->_next;
		}
		//走到这说明没有相同的元素，可以进行插入，
		//由于哈希桶不规定产生冲突的序列有序,可以进行头插比较简单
		Node* newnode = new Node(v);
		newnode->_next = _table[index];
		_table[index] = newnode;

		++_size;
		return true;
	}

insert

三、构建哈希表的迭代器
  • 在实现迭代器之前，我们先得了解一个哈希表，之前也介绍了拉链法实现的哈希表其实是一个数组存储了一系列的指针，指针又链接了每个桶里产生哈希冲突的节点。
  • 迭代器主要是为了遍历哈希表的元素，因此最主要是要实现迭代器的operator++，主要分为两种情况，第一种情况：要是在一个桶里面，就是产生哈希冲突的节点之间，operator++只需要返回节点的_next即可， 第二种情况：需要处理的是当已经走到一个桶的最后要寻找下一个桶的位置的情况
  • 由于我们需要处理第二种情况，所有我们需要有一个指向哈希表的指针，所以迭代器中有两个成员一个是指向哈希节点的指针，一个是指向哈希表的指针。
//前置声明，由于哈希表需要迭代器，迭代器又需要哈希表
template<class K, class V, class KeyOfValue,class HashFunc>
class HashTable;

//实现哈希表的迭代器
template<class K, class V, class KeyOfValue, class HashFunc>
struct HTIterator
{
	typedef HashNode<V> Node;
	typedef HTIterator<K, V, KeyOfValue, HashFunc> Self;

	Node* _node;//节点指针
	HashTable<K, V, KeyOfValue,HashFunc>* _ht;//哈希表指针

	HTIterator(Node* node, HashTable<K, V, KeyOfValue,HashFunc>* ht)
		:_node(node)
		, _ht(ht)
	{}

	V& operator*()//返回节点的值
	{
		return _node->_valuefiled;
	}
	
	V* operator->()//返回节点指针
	{
		return &_node->_valuefiled;
	}

	Self& operator++()
	{
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else
		{
			// 找下一个桶的第一个节点位置
			//size_t i = KeyOfValue()(_node->_valuefiled) % _ht->_table.size();
			size_t i = _ht->HashIndex(KeyOfValue()(_node->_valuefiled), _ht->_table.size());
			++i;
			for (; i < _ht->_table.size(); ++i)
			{
				if (_ht->_table[i] != nullptr)
				{
					_node = _ht->_table[i];
					break;
				}
			}

			if (i == _ht->_table.size())
			{
				_node = nullptr;
			}
		}

		return *this;
	}

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

构造UnorderedMap

#include "HashTable.h"
#include "common.h"

template<class K, class V,class HashFunc = HashFunc<K>>
class UnorderedMap
{
	struct MapKeyOfValue
	{
		const K& operator()(const pair<K, V>& _kv)
		{
			return _kv.first;
		}
	};
public:
	typedef typename HashTable<K, pair<K, V>, MapKeyOfValue, HashFunc>::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)
	{
		std::pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
		return ret.first->second;
	}

private:
	HashTable<K, pair<K, V>, MapKeyOfValue,HashFunc> _ht;
};

构造UnorderedSet

#include "HashTable.h"
#include "common.h"

template<class K,class HashFunc = HashFunc<K>>
class UnorderedSet
{
	struct SetKeyOfValue
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename HashTable<K, K, SetKeyOfValue, HashFunc>::iterator iterator;

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

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

	pair<iterator,bool> Insert(const K& key)
	{
		return _ht.Insert(key);
	}
private:
	HashTable<K, K, SetKeyOfValue,HashFunc> _ht;
};

HashFunc模板参数

  • 上述代码中不仅出现了一次的HashFunc肯定有所困惑，下面就解释一下HashFunc的作用
  • 我们之前一只没有对这个模板参数进行详细的讲解，这里我们单独将他拿出来进行探讨，首先读者们应该明白要将数据映射到哈希表中，K值必须是一个可以取模的值，那么现在问题来了，我们之前在使用unordered_map/set时我们发现string也可以进行映射，但是我们能对string直接进行取模呢？答案当然是不能，所以这里我们就要借助HashFunc这个仿函数对string类型进行取模。
字符串哈希算法

那么说到这里，这个字符串哈希算法应该怎么实现呢？

  • 情景1：将字符串的第一个字符作为K映射 缺点：那么以某个字符开头的字符串全部都被映射在同一个位置
  • 情景2：将字符串中的所有字符asll值加起来作为K映射 缺点：“abcd”,“acdb”,“adbc”…都被映射在同一个位置

由此可见上述两种情景都不是最好的解决办法，因此参考字符串哈希函数 字符串哈希函数
我们可以通过下面的代码解决string的哈希映射问题

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (size_t i = 0; i < s.size(); ++i)
		{
			hash = hash * 131 + s[i];
		}
		return hash;
	}
};

看到这里可能有人会疑惑，既然有了HashFunc这个模板参数了，那我们平时使用unordered_map/set的时候为什么没有传这个参数就可以直接使用了呢？这里就体现了缺省参数和模板特化的强大了
HashFunc

哈希源码

  • HashTable.h
#pragma once

//开散列解决哈希冲突，哈希桶、拉链法
#include <iostream>
#include <vector>
using namespace std;

template<class V>
struct HashNode
{
	//由于之后要用哈希桶封装unordered_map/set，因此这里可能存pair<K,V>也可能存value
	V _valuefiled;
	HashNode<V>* _next;//哈希桶结构是一个vector数组下挂着链表，定义一个指针指向下一个节点的位置

	HashNode(const V& v)
		:_valuefiled(v)
		, _next(nullptr)
	{}
};

//前置声明，由于哈希表需要迭代器，迭代器又需要哈希表
template<class K, class V, class KeyOfValue,class HashFunc>
class HashTable;

//实现哈希表的迭代器
template<class K, class V, class KeyOfValue, class HashFunc>
struct HTIterator
{
	typedef HashNode<V> Node;
	typedef HTIterator<K, V, KeyOfValue, HashFunc> Self;

	Node* _node;//节点指针
	HashTable<K, V, KeyOfValue,HashFunc>* _ht;//哈希表指针

	HTIterator(Node* node, HashTable<K, V, KeyOfValue,HashFunc>* ht)
		:_node(node)
		, _ht(ht)
	{}

	V& operator*()//返回节点的值
	{
		return _node->_valuefiled;
	}
	
	V* operator->()//返回节点指针
	{
		return &_node->_valuefiled;
	}

	Self& operator++()
	{
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else
		{
			// 找下一个桶的第一个节点位置
			//size_t i = KeyOfValue()(_node->_valuefiled) % _ht->_table.size();
			size_t i = _ht->HashIndex(KeyOfValue()(_node->_valuefiled), _ht->_table.size());
			++i;
			for (; i < _ht->_table.size(); ++i)
			{
				if (_ht->_table[i] != nullptr)
				{
					_node = _ht->_table[i];
					break;
				}
			}

			if (i == _ht->_table.size())
			{
				_node = nullptr;
			}
		}

		return *this;
	}

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

//由于之后要用哈希桶封装unordered_map/set，因此这里可能存pair<K,V>也可能存value
//由于pair<K,V>存储比较必须取key才能比较，因此传仿函数取key
//传HashFunc是为了将一个不能直接取模的key类型，eg：string
template<class K, class V, class KeyOfValue, class HashFunc>
class HashTable
{
	typedef HashNode<V> Node;
public:
	template<class K, class V, class KeyOfValue, class HashFunc>
	friend struct HTIterator;
	typedef HTIterator<K, V, KeyOfValue,HashFunc> iterator;

	HashTable()
		:_size(0)
	{}

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

		return iterator(nullptr, this);
	}

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

	pair<iterator,bool> Insert(const V& v)
	{
		//考虑增容
		CheckCapacity();

		KeyOfValue kov;
		const K& key = kov(v);
		//size_t index = key % _table.size();
		size_t index = HashIndex(key, _table.size());

		Node* cur = _table[index];
		while (cur)
		{
			if (kov(cur->_valuefiled) == key)
				return make_pair(iterator(cur, this), false);
			cur = cur->_next;
		}
		//走到这说明没有相同的元素，可以进行插入，
		//由于哈希桶不规定产生冲突的序列有序,可以进行头插比较简单
		Node* newnode = new Node(v);
		newnode->_next = _table[index];
		_table[index] = newnode;

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

	void CheckCapacity()
	{
		//当负载因子==1时扩容
		if (_table.size() == _size)
		{
			size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
			//这里不像之前开散列一样创建一个新的哈希表
			//再调用Insert的原因是旧表的节点可以直接拿到新的vector数组中进行插入
			vector<Node*> newtable;
			newtable.resize(newsize);

			//遍历旧表，在新的vector数组中找到对应位置，将旧表节点插入
			for (size_t i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				//将节点从旧表中拆出来，再重新计算节点在新表中的位置进行插入
				while (cur)
				{
					Node* next = cur->_next;
					//size_t index = KeyOfValue()(cur->_valuefiled) % newsize;
					size_t index = HashIndex(KeyOfValue()(cur->_valuefiled), newsize);
					//头插入新表中
					cur->_next = newtable[index];
					newtable[index] = cur;

					cur = next;
				}
				//将原来的表置空
				_table[i] = nullptr;
			}
			//交换新旧两标的资源，出作用域后新表自动调用析构函数释放旧表资源
			_table.swap(newtable);
		}
	}

	Node* Find(const K& key)
	{
		//size_t index = key % _table.size();
		size_t index = HashIndex(key, _table.size());
		Node* cur = _table[index];
		while (cur)
		{
			if (KeyOfValue()(cur->_valuefiled) == key)
				return cur;

			cur = cur->_next;
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		//size_t index = key % _table.size();
		size_t index = HashIndex(key, _table.size());
		Node* cur = _table[index];
		Node* prev = nullptr;

		while (cur)
		{
			if (KeyOfValue()(cur->_valuefiled) == key)
			{
				if (prev == nullptr)//头删
					_table[index] = cur->_next;
				else
					prev->_next = cur->_next;

				delete cur;
				--_size;
				return true;
			}
		}
		return false;
	}

	size_t HashIndex(const K& key, size_t size)
	{
		HashFunc hf;
		return hf(key) % size;
	}
private:
	vector<Node*> _table;//vector中的size为哈希表的大小
	size_t _size;//哈希表中存储的有效元素的个数
};
  • UnorderedMap.h
#include "HashTable.h"
#include "common.h"

template<class K, class V,class HashFunc = HashFunc<K>>
class UnorderedMap
{
	struct MapKeyOfValue
	{
		const K& operator()(const pair<K, V>& _kv)
		{
			return _kv.first;
		}
	};
public:
	typedef typename HashTable<K, pair<K, V>, MapKeyOfValue, HashFunc>::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)
	{
		std::pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
		return ret.first->second;
	}

private:
	HashTable<K, pair<K, V>, MapKeyOfValue,HashFunc> _ht;
};

void TestUnorderedMap()
{
	UnorderedMap<int, int> m;
	m.Insert(std::make_pair(15, 15));
	m.Insert(std::make_pair(5, 5));
	m.Insert(std::make_pair(25, 25));
	m[7] = 6;

	for (size_t i = 0; i < 11; ++i)
	{
		m.Insert(make_pair(i, i));
	}

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

void TestUnorderedMap2()
{
	UnorderedMap<string, string> sm;
	sm.Insert(make_pair(string("sort"), string("排序")));
	sm.Insert(make_pair(string("left"), string("左边")));
	sm.Insert(make_pair(string("string"), string("字符串")));
	sm.Insert(make_pair(string("insert"), string("插入")));

	for (auto& kv : sm)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
  • UnorderedSet
#include "HashTable.h"
#include "common.h"

template<class K,class HashFunc = HashFunc<K>>
class UnorderedSet
{
	struct SetKeyOfValue
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename HashTable<K, K, SetKeyOfValue, HashFunc>::iterator iterator;

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

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

	pair<iterator,bool> Insert(const K& key)
	{
		return _ht.Insert(key);
	}
private:
	HashTable<K, K, SetKeyOfValue,HashFunc> _ht;
};

void TestUnorderedSet()
{
	UnorderedSet<int> s;
	s.Insert(1);
	s.Insert(5);
	s.Insert(3);
	s.Insert(10);
	s.Insert(5);
	s.Insert(19);
	s.Insert(3);
	s.Insert(2);
	s.Insert(8);

	for (auto& e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}
  • common.h//HashFunc
#pragma once
#include <iostream>
#include <string>

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

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (size_t i = 0; i < s.size(); ++i)
		{
			hash = hash * 131 + s[i];
		}
		return hash;
	}
};
CXYhh121
关注
专栏目录
C++实现哈希表。
TPON的博客
11-17 6581
C++模拟实现哈希表
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 835
C++实现哈希表封装unordered_map unordered_set
unorder_map与map
weixin_41167925的博客
08-29 944
1.C++ 常用的map类容器就是 map 和 unordered_map map的实现原理就是红黑树 每个节点到叶子节点最大树高不超过1 是平衡二叉树。查找的时间复杂度是O(lgn),但是插入和删除要维持红黑树的自平衡，所以效率较低。但是有序。 unordered_map是c++11正式加入的对hashmap的官方实现（之前标准c++没有对hashmap的官方实现，我们用的都是非官方的实现，例如平台自己的实现，hash_map中也建议以后都使用unordered_map不要使用hashmap）,从名字
Unordered_map和Unordered_set的底层实现（C++）
菜鸟康的博客
07-27 835
应用链地址法处理溢出的情况时需要增设链接指针，看起来似乎增加了存储开销，但是事实上由于开地址法必须保持大量的空闲空间以确保搜索的效率，而表项所占的空间又比指针大很多，所以使用链地址法比开放空间法更节省存储空间。
从零带你底层实现unordered_map （1）
陈大大陈的博客
11-20 1019
它是一个单向的迭代器。 为什么专门提到这个呢？因为这是我踩过坑的地方！！ 单向迭代器压根就不能使用sort函数来排序！ std::unordered_map的迭代器类型是ForwardIterator，而不是sort函数要求的RandomAccessIterator，这里不符合。 我们要排序的话，还是将unordered_map里存的值，转存到vector里面。 然后我们再自定义一个排序方法，对vector进行排序。
哈希表的底层实现(1)---C++版
最新发布
2301_80377335的博客
09-08 743
比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4， 因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中。//三个状态，这里定义了哈希表中的数据的多个状态，在红黑树的模拟实现中有用过，这样方便判断此位置的数据状态，方便以后的线性探测和删除数据等。
C++【unordered_map/set的底层实现-哈希表】—含有源代码
m0_59292239的博客
06-09 3015
C++【unordered_map/set的底层实现-哈希表】—含有源代码
c++ unordered_set/unordered_map的底层理解及其实现，位图实现及其应用，布隆过滤器的实现及其应用，哈希切分的应用
qq_54626677的博客
02-04 950
unordered_map在线文档说明unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
初识C++之unordered_map与unordered_set
Masquerena114514的博客
04-07 2229
本文主要讲述了通过对哈希桶的改造，使得unordered_set和unordered_map能够对同一个哈希桶进行封装并模拟实现
侯捷C++ STL：哈希表（unordered_set,unordered_multiset,unordered_map,unordered_multimap）的底层实现
weixin_39770712的博客
11-09 895
哈希表的产生由于内存不够一一映射。于是乎在空间不足时取余数。 为了防止某一个链表过长，这里根据经验来制定规则。当插入的元素个数等于buckets时这时哈希表要扩容。扩容因子是两倍。但是buckets值尽量是质数，选择质数是为了尽量做到均匀散列。所以扩容后要找两倍大后附近的质数。编译器将空间扩容的空间大小都自己定义好了，不用重新计算空间，53-97-193…。 底层实现： HashFcn：一个对象如何映射为一个号码/编号。hasher,key_equal,ExtractKey是function objec
哈希表封装实现 unordered_map 和 unordered_set——哈希表の华丽二重奏
qq_61500888的博客
10-04 1980
带你一命通关 unordered_map 和 unordered_set 底层 十分钟手撕数据结构原理
哈希表的实现
07-06
C++实现简单的哈希表，插入，查找，销毁。
【C++】“最强查找“哈希表的底层实现
Sxy_wspsby的博客
05-27 1668
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
【C++】封装哈希表 && unordered_map和unordered_set容器
Dawn_Lillian的博客
04-30 854
封装哈希表 && unordered_map和unordered_set容器
C++ 哈希表及unordered_set + unordered_map容器
冰果滴的博客
09-14 3212
前言：unordered_set和unordered_map是C++11中新增加的两个关联式容器，使用方式与set和map基本相同，但是unordered_set和unordered_map的底层是哈希表，而set和map的底层是红黑树。并且unordered_set不能排序；unordered_set和unordered_map是单向迭代器；效率要高一下，时间复杂度为O(1)。
unorder_map的底层实现方法
一面之媛
08-28 1577
哈希表 哈希表是一个K_V的结构，，，，又被称为是散列表！！！！！ 它是根据关键字(key)来直接访问这个内存存储数据位置的数据结构； 在构建哈希表的方法，我们这里主要介绍两种方法： 1、直接地址法； 什么意思呢？？？？？ 就是直接取key(或者是某种线性函数)作为这个下表来存储数据 ，，，key在这里称作是 散列地址。。。 可以理解成这个样子 Hash（Key）= Key 或Hash（Key）= A*Key + B，A、B为常数。。。。 2、除留余数法； 这里方法的说法是： 就是..
C++ unordered_set
RoyalLAW的博客
06-20 371
c++ unordered_set
C++——unordered_set
m0_51467734的博客
07-26 263
unordered_set是一种使用hash值作为key的容器，是单值型存储方式。 而unordered_map是key-value形式存储。 方法： .insert() .insert({ , , ,}) .insert(b.begin(),b.end()) a.find() 查找元素，返回结果为a.end()则表明没有找到，否则返回对应元素 a.count() 查找元素有几个，但由于此容器中没有相同元素，所以可以看作是 检查容器中是否已有该元素。 .clear() .era...
unordered_map(26)
09-04
引用: unordered_map底层是哈希表。哈希表是一种根据键的哈希值进行快速查找的数据结构。引用: unordered_map使用哈希桶中的HashTable的迭代器来实现迭代器和operator[]的功能。它使用哈希值将元素存储在桶中，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值