【C++】深入哈希表核心：从改造到封装，解锁 unordered_set 与 unordered_map 的终极奥义！

做人不要太理性2024-11-23 9:28

文章目录

  • 修改哈希表
    • 模板参数
    • 迭代器
    • [``HashTable`` 的默认成员函数](#HashTable 的默认成员函数)
    • [``HashTable`` 迭代器相关函数](#HashTable 迭代器相关函数)
    • [``HashTable`` 的 ``Insert`` 函数](#HashTable 的 Insert 函数)
    • [``HashTable`` 的 ``Find``函数](#HashTable 的 Find函数)
    • [``HashTable`` 的 ``Erase``函数](#HashTable 的 Erase函数)
  • [封装 unordered_set](#封装 unordered_set)
  • [封装 unordered_map](#封装 unordered_map)
  • [测试 unordered_set 和 unordered_map](#测试 unordered_set 和 unordered_map)

修改哈希表

我们基于链地址法 实现的哈希表来封装实现 unordered_set 和 unordered_map ，但是由于实现的哈希表是 Key-Value 结构的并且我们的实现的哈希表缺少了迭代器，所以我们需要对之前实现的哈希表进行改造。

模板参数

HashNode

节点里不再存储确定的 pair<K, V> ，而是类型 T ，代表代表存储的数据可能是 key 或者 key-Value 。

cpp 复制代码 
template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* _next;

	HashNode(const T& data)
		:_data(data)
		, _next(nullptr)
	{}
};

HashTable

cpp 复制代码 
template<class K, class T, class KeyOfT, class hash = HashFunc<K>>
class HashTable
  • K ：代表的是 key
  • T ：代表是存的可能是 key 或者 key-value
  • KeyOfT ：仿函数，目的是拿到 T 里面的 key

迭代器

哈希表的迭代器其实就是对节点指针进行封装，而且是单向迭代器，只需实现 ++ 即可。

cpp 复制代码 
//哈希表与迭代器相互依赖，需要前置声明
template<class K, class T, class KeyOfT, class hash>
class HashTable;

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

	Node* _node;
	//需要用到哈希表里的数组大小，故需要指向哈希表的指针
	const HT* _pht;

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

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

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

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

由于哈希表的特殊性，其迭代器的 ++ 较为复杂，也是实现哈希表迭代器的重点。
重载 ++

迭代器的++分为两种情况：

  • 当前迭代器不是哈希桶的最后一个节点，直接走到下一个节点。
  • 当前迭代器是哈希桶的最后一个节点，需要找下一个不为空的哈希桶的头节点。

cpp 复制代码 
Self& operator++()
{
	//当前哈希桶还有数据，直接到下一个节点
	if (_node->_next)
	{
		_node = _node->_next;
	}
	//当前哈希桶走完了，寻找下一个不为空的哈希桶
	else if (_node->_next == nullptr)
	{
		KeyOfT kot;
		Hash hashfunc;
		size_t hashi = hashfunc(kot(_node->_data)) % _pht->_tables.size();
		++hashi;

		while (hashi < _pht->_tables.size())
		{
			_node = _pht->_tables[hashi];

			//找到了下一个桶
			if (_node)
				break;
			else
				++hashi;
		}
		
		//处理迭代器在最后一个不为空的哈希桶的最后一个节点的情况
		if (hashi == _pht->_tables.size())
		{
			_node = nullptr;
		}

	}

	return *this;
}

Self& operator++(int)
{
	Self tmp = *this;
	++(*this);
	return tmp;
}

HashTable 的默认成员函数

cpp 复制代码 
//构造函数
HashTable()
	: _tables(__stl_next_prime(0))
	, _n(0)
{}

//拷贝构造函数
HashTable(const HashTable<K, T, KeyOfT, hash>& ht)
{
	_tables.resize(ht._tables.size());
	for (auto& data : ht)
	{
		Insert(data);
	}
}

//赋值重载
HashTable<K, T, KeyOfT, hash>& operator=(const HashTable<K, T, KeyOfT, hash>& ht)
{
	vector<Node*> newtables(ht._tables.size());
	for (size_t i = 0; i < ht._tables.size(); ++i)
	{
		Node* cur = ht._tables[i];
		while (cur)
		{
			Node* newnode = new Node(cur->_data);
			newnode->_next = newtables[i];
			newtables[i] = newnode;
			cur = cur->_next;
		}
	}
	_tables.swap(newtables);
	return *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;
	}
}

HashTable 迭代器相关函数

cpp 复制代码 
typedef HTIterator<K, T, KeyOfT, hash, T&, T*> Iterator;
typedef HTIterator<K, T, KeyOfT, hash, const T&, const T*> Const_Iterator;

Iterator begin()
{
	if (_n == 0)
		return end();

	for (size_t i = 0; i < _tables.size(); ++i)
	{
		Node* cur = _tables[i];
		if (cur)
		{
			return Iterator(cur, this);
		}
	}

	return end();
}

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

Const_Iterator begin() const
{
	if (_n == 0)
		return end();

	for (size_t i = 0; i < _tables.size(); ++i)
	{
		Node* cur = _tables[i];
		if (cur)
		{
			return Const_Iterator(cur, this);
		}
	}

}

Const_Iterator end() const
{
	return Const_Iterator(nullptr, this);
}

begin() 对应的迭代器应该是哈希表中第一个非空的哈希桶的头节点，需要特别处理。
end() 直接返回空指针对应的迭代器即可。

HashTable 的 Insert 函数

对于 Insert 函数，只需将其返回值改成迭代器 与布尔值 的 pair ，再将原本关于使用到 key 的地方套一层 KeyOfT 实例化出来的对象即可。

cpp 复制代码 
void CheckCapacity()
{
	if (_n == _tables.size())
	{
		//把哈od希桶里的链表每个节点拆下来插入newht效率太低了
		/*HashTable<K, V> newht;
		newht._tables.resize(__stl_next_prime(_tables.size() + 1));
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				newht.Insert(cur->_kv);
				cur = cur->_next;
			}
		}
		_tables.swap(newht._tables);*/

		KeyOfT kot;
		hash hashfunc;
		vector<Node*> newtables(__stl_next_prime(_tables.size() + 1));
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				size_t hashi = hashfunc(kot(cur->_data)) % newtables.size();
				//头插
				cur->_next = newtables[hashi];
				newtables[hashi] = cur;

				cur = next;
			}

			_tables[i] = nullptr;
		}
		_tables.swap(newtables);
	}
}

pair<Iterator, bool> Insert(const T& data)
{

	KeyOfT kot;
	Iterator it = Find(kot(data));
	//不等于end()说明哈希表里有重复元素
	if (it != end())
		return { it, false };

	//检查是否需要扩容
	CheckCapacity();

	hash hashfunc;
	size_t hashi = hashfunc(kot(data)) % _tables.size();

	Node* newnode = new Node(data);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;

	return { Iterator(newnode, this), false };
}

HashTable 的 Find函数

将返回值改为迭代器，原本用到 key 的地方套一层 KeyOfT 实例化出来的对象即可。

cpp 复制代码 
Iterator Find(const K& key)
{
	KeyOfT kot;
	hash hashfunc;
	size_t hashi = hashfunc(key) % _tables.size();
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (kot(cur->_data) == key)
		{
			return Iterator(cur, this);
		}
		cur = cur->_next;
	}

	//没找到就返回
	return end();
}

HashTable 的 Erase函数

跟 Insert 函数的处理基本一样，不多叙述了。

cpp 复制代码 
bool Erase(const K& key)
{
	KeyOfT kot;
	hash hashfunc;
	size_t hashi = hashfunc(key) % _tables.size();
	Node* prev = nullptr;
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (kot(cur->_data) == key)
		{
			//删除头节点的情况
			if (prev == nullptr)
			{

				_tables[hashi] = cur->_next;
			}
			//非头节点的情况
			else
			{
				prev->_next = cur->_next;
			}

			delete cur;
			--_n;

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

	return false;
}

封装 unordered_set

对 HashTable 的迭代器和函数进行封装即可，灰常简单。

cpp 复制代码 
template<class K, class hash = HashFunc<K>>
class unordered_set
{
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};

public:
	typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, hash>::Iterator iterator;
	typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, hash>::Const_Iterator const_iterator;

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

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

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

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

封装 unordered_map

也是对 HashTable 的迭代器和函数进行封装，但有所不同的是，还需要多重载 [] ，也比较简单。

cpp 复制代码 
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;
	typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, hash>::Const_Iterator const_iterator;

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

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

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

	const_iterator end() const
	{
		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 = Insert({ key, V() });
		return ret.first->second;
	}

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

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

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

测试 unordered_set 和 unordered_map



拜拜，下期再见😏

摸鱼ing😴✨🎞

相关推荐
我们的五年9 分钟前
【Linux课程学习】：进程描述---PCB（Process Control Block）
linux·运维·c++
程序猿阿伟25 分钟前
《C++ 实现区块链：区块时间戳的存储与验证机制解析》
开发语言·c++·区块链
爱摸鱼的孔乙己1 小时前
【数据结构】链表（leetcode）
c语言·数据结构·c++·链表·csdn
烦躁的大鼻嘎2 小时前
模拟算法实例讲解：从理论到实践的编程之旅
数据结构·c++·算法·leetcode
IU宝2 小时前
C/C++内存管理
java·c语言·c++
fhvyxyci2 小时前
【C++之STL】摸清 string 的模拟实现（下）
开发语言·c++·string
C++忠实粉丝2 小时前
计算机网络socket编程(4)_TCP socket API 详解
网络·数据结构·c++·网络协议·tcp/ip·计算机网络·算法
古月居GYH2 小时前
在C++上实现反射用法
java·开发语言·c++
Betty’s Sweet2 小时前
[C++]：IO流
c++·文件·fstream·sstream·iostream
祁思妙想2 小时前
10.《滑动窗口篇》---②长度最小的子数组（中等）
leetcode·哈希算法
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作