【C++】STL之unoerdered_map、unordered_set类源码剖析

目录

概述

源码

HashTable.h

UnorderedMap.h

UnorderedSet.h

test.cpp

---

概述

STL标准模板库中的map、set的底层数据结构是红黑树，会在数据插入时自动排序，unordered_map、unordered_set的底层数据结构是哈希表，不做排序，根据哈希值进行映射。

哈希算法可见这篇文章：

【C++】哈希_种花家de小红帽的博客-CSDN博客

unordered_map、unordered_set的特性与map、set基本一样，数据插入和删除的效率都差不多，但是unordered_map、unordered_set的查询效率远高于map、set。

unordered_map、unordered_set的封装与map、set的封装很相似。

封装细节、迭代器设计具体可见这篇文章：

【C++】STL之map、set类源码剖析_种花家de小红帽的博客-CSDN博客

源码

HashTable.h

#pragma once
#include 
#include 

// 仿函数
template
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 特化
template<>
struct HashFunc
{
	size_t operator()(const std::string& str)
	{
		size_t res = 0;
		for (const auto& ch : str)
		{
			res *= 131;		// 随机数取值，避免哈希冲突
			res += ch;
		}
		return res;
	}
};

// 节点
template
struct HashNode
{
	T _data;
	HashNode* next;

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

// 前置声明
template
class HashTable;

// 迭代器
template
struct Iterator
{
	typedef HashNode Node;
	typedef Iterator Self;
	typedef HashTable HT;

	Node* _node;
	HT* _ht;
	Iterator(Node* node, HT* ht)
		: _node(node), _ht(ht)
	{}

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

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

	Self& operator++()
	{
		if (_node->next)
		{
			_node = _node->next;
		}
		else
		{
			// 寻找下一个桶的第一个节点
			KofT kot;
			Hash hs;
			size_t pos = hs(kot(_node->_data)) % _ht->_table.size();
			++pos;
			while (pos < _ht->_table.size())
			{
				if (_ht->_table[pos] == nullptr)
				{
					++pos;
				}
				else
				{
					_node = _ht->_table[pos];
					break;
				}
			}
			if (pos == _ht->_table.size())
			{
				_node = nullptr;
			}
		}

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

// 哈希桶
template
class HashTable
{
	typedef HashNode Node;

	template
	friend struct Iterator;

public:
	typedef Iterator iterator;
	typedef Iterator const_iterator;

	iterator begin()
	{
		for (int 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);
	}

	const_iterator begin()const
	{
		for (int i = 0; i < _table.size(); ++i)
		{
			if (_table[i] != nullptr)
			{
				return const_iterator(_table[i], this);
			}
		}
		return const_iterator(nullptr, this);
	}
	const_iterator end()const
	{
		return const_iterator(nullptr, this);
	}

	// 迭代器拷贝构造
	template
	HashTable(InputIterator first, InputIterator last)
	{
		_n = 0;
		_table.resize(10);
		while (first != last)
		{
			insert(*first);
			++first;
		}
	}

	void swap(HashTable& ht)
	{
		std::swap(_table, ht._table);
		std::swap(_n, ht._n);
	}

	HashTable(const HashTable& ht)
	{
		HashTable tmp(ht.begin(), ht.end());
		swap(tmp);
	}

	HashTable& operator=(HashTable ht)
	{
		swap(ht);
		return *this;
	}

	HashTable()
		: _n(0)
	{
		_table.resize(10, nullptr);
	}

	~HashTable()
	{
		for (int i = 0; i < _table.size(); ++i)
		{
			Node* cur = _table[i];
			while (cur)
			{
				Node* next = cur->next;
				delete cur;
				cur = next;
			}
			_table[i] = nullptr;
		}
	}

	std::pair insert(const T& data)
	{
		KofT koft;
		iterator it = find(koft(data));
		if (it != end())
		{
			return std::make_pair(it, false);
		}

		// 扩容, 平衡因子为 1
		if (_n == _table.size())
		{
			std::vector newTable;
			newTable.resize(_table.size() * 2, nullptr);
			for (int i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->next;
					size_t pos = Hash()(koft(cur->_data)) % newTable.size();
					if (newTable[pos] == nullptr)
					{
						newTable[pos] = cur;
						cur->next = nullptr;
					}
					else
					{
						cur->next = newTable[pos];
						newTable[pos] = cur;
					}
					cur = next;
				}
			}
			_table.swap(newTable);
		}

		// 插入节点
		Node* newNode = new Node(data);
		size_t pos = Hash()(koft(data)) % _table.size();
		newNode->next = _table[pos];
		_table[pos] = newNode;
		++_n;

		return std::make_pair(iterator(newNode, this), true);
	}

	iterator find(const K& key)
	{
		size_t pos = Hash()(key) % _table.size();
		Node* cur = _table[pos];
		while (cur)
		{
			if (KofT()(cur->_data) == key)
			{
				return iterator(cur, this);
			}
			cur = cur->next;
		}

		return iterator(nullptr, this);
	}

	bool erase(const K& key)
	{
		iterator it = find(key);
		if (it != end())
		{
			size_t pos = Hash()(key) % _table.size();
			Node* cur = _table[pos];
			if (cur == it._node)
			{
				cur = it._node->next;
				delete it._node;
				it._node = nullptr;
			}
			else
			{
				while (cur->next != it._node)
				{
					cur = cur->next;
				}
				cur->next = it._node->next;
				delete it._node;
				it._node = nullptr;
			}
			--_n;
			return true;
		}
		else
		{
			return false;
		}
	}

private:
	std::vector _table;
	size_t _n;
};

UnorderedMap.h

#pragma once
#include "HashTable.h"

template>
class UnorderedMap
{
	struct MapKofT
	{
		const K& operator()(const std::pair& kv)
		{
			return kv.first;
		}
	};
public:
	typedef typename HashTable, Hash, MapKofT>::iterator iterator;
	typedef typename HashTable, Hash, MapKofT>::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();
	}

	// 迭代器构造
	template
	UnorderedMap(InputIterator first, InputIterator last)
	{
		_ht = HashTable, Hash, MapKofT>(first, last);
	}

	UnorderedMap(UnorderedMap& uMap)
	{
		_ht = HashTable, Hash, MapKofT>(uMap.begin(), uMap.end());
	}

	UnorderedMap& operator=(UnorderedMap& uMap)
	{
		_ht = HashTable, Hash, MapKofT>(uMap.begin(), uMap.end());
		return *this;
	}

	UnorderedMap()
		: _ht(HashTable, Hash, MapKofT>())
	{}

	std::pair insert(const std::pair& kv)
	{
		return _ht.insert(kv);
	}

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

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

	V& operator[](const K& key)
	{
		std::pair ret = _ht.insert(std::make_pair(key, V()));
		return ret.first->second;
	}

private:
	HashTable, Hash, MapKofT> _ht;
};

UnorderedSet.h

#pragma once
#include "HashTable.h"

template>
class UnorderedSet
{
	struct SetKofT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename HashTable::iterator iterator;
	typedef typename HashTable::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();
	}

	// 迭代器构造
	template
	UnorderedSet(InputIterator first, InputIterator last)
	{
		_ht = HashTable(first, last);
	}

	UnorderedSet(UnorderedSet& uSet)
	{
		_ht = HashTable(uSet.begin(), uSet.end());
	}

	UnorderedSet& operator=(UnorderedSet& uSet)
	{
		_ht = HashTable(uSet.begin(), uSet.end());
		return *this;
	}

	UnorderedSet()
		: _ht(HashTable())
	{}

	std::pair insert(const K& key)
	{
		std::pair ret = _ht.insert(key);
		return std::make_pair(ret.first, ret.second);
	}

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

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

private:
	HashTable _ht;
};

test.cpp

#include "UnorderedMap.h"
#include "UnorderedSet.h"
#include 
using namespace std;

void unordered_map_test1()
{
	int arr[] = { 34, 36, 12, 54, 5, 22, 65, 32, 13, 4, 1, 52 };

	cout << "uMap1:" << endl;
	UnorderedMap uMap1;
	for (const auto& e : arr)
	{
		uMap1.insert(make_pair(e, e));
	}
	for (const auto& e : uMap1)
	{
		cout << e.first << ": " << e.second << endl;
	}
	cout << endl;

	cout << uMap1.find(32)._node << endl;
	cout << uMap1.find(42)._node << endl;
	cout << uMap1.find(52)._node << endl;
	uMap1.erase(32);
	cout << uMap1.find(32)._node << endl;
	cout << uMap1.find(42)._node << endl;
	cout << uMap1.find(52)._node << endl;

	UnorderedMap::iterator it1 = uMap1.begin();
	while (it1 != uMap1.end())
	{
		cout << it1._node->_data.first << ": " << it1._node->_data.second << endl;
		++it1;
	}
	cout << endl;

	// 迭代器构造
	cout << "uMap2:" << endl;
	UnorderedMap uMap2(uMap1.begin(), uMap1.end());
	UnorderedMap::iterator it2 = uMap2.begin();
	while (it2 != uMap2.end())
	{
		cout << (*it2).first << ": " << (*it2).second << endl;
		++it2;
	}
	cout << endl;

	// 拷贝构造
	cout << "uMap3:" << endl;
	UnorderedMap uMap3(uMap2);
	UnorderedMap::iterator it3 = uMap3.begin();
	while (it3 != uMap3.end())
	{
		cout << (*it3).first << ": " << (*it3).second << endl;
		it3++;
	}
	cout << endl;
}

void unordered_map_test2()
{
	std::vector food = {
		"蛋糕", "西瓜", "啤酒", "苹果", "香蕉", "蛋糕", "牛肉",
		"西瓜", "苹果", "啤酒", "西瓜", "牛肉", "蛋糕", "蛋糕",
		"西瓜", "西瓜", "牛肉", "苹果", "香蕉", "蛋糕", "西瓜"
	};

	UnorderedMap foodMap;
	for (auto& e : food)
	{
		foodMap[e]++;
	}
	for (auto& e : foodMap)
	{
		std::cout << e.first << ": " << e.second << std::endl;
	}
	std::cout << std::endl;
}

void unordered_set_test()
{
	int arr[] = { 34, 36, 12, 54, 5, 22, 65, 32, 13, 4, 1, 52 };

	cout << "uSet1:" << endl;
	UnorderedSet uSet1;
	for (const auto& e : arr)
	{
		uSet1.insert(e);
	}
	for (auto& e : uSet1)
	{
		cout << e << ' ';
	}
	cout << endl;

	cout << "uSet2:" << endl;
	UnorderedSet uSet2(uSet1.begin(), uSet1.end());
	for (auto& e : uSet2)
	{
		cout << e << ' ';
	}
	cout << endl;

	cout << "uSet3:" << endl;
	UnorderedSet uSet3(uSet2);
	UnorderedSet::iterator it3 = uSet3.begin();
	while (it3 != uSet3.end())
	{
		cout << *it3 << ' ';
		++it3;
	}
	cout << endl;
}

int main()
{
	unordered_map_test1();
	unordered_map_test2();
	unordered_set_test();

	return 0;
}