哈希表+unordered_map封装

目录

 1：hashtable.h

2：unordered_map.h

 3：unordered_set

4：讲解

---

 1：hashtable.h

#pragma once
#include
using namespace std;
namespace OpenAdress
{
	enum State
	{
		EXIST,
		DELETE,
		EMPTY,
	};
	template
	struct HashData
	{
		pair _kv;
		State _state = EMPTY;
	};



	template
	class HashTable
	{
	public:
		bool Insert(const pair& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			if (_tables.size() == 0 || (_n * 10 / _tables.size()) >= 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable _newht;
				_newht._tables.resize(newsize);//必须开新表，不能直接写，否则映射关系改变
				for (auto& data : _tables)
				{
					_newht.Insert(data._kv);
				}
				_tables.swap(_newht._tables);
			}

			size_t hashi = kv.first % _tables.size();
			size_t i = 1;
			size_t index = hashi;
			while (_tables[index]._state == EXIST)//3 13 23 33删除23 如果判断
			{
				index = hashi + i;
				index %= _tables.size();
				++i;
			}
			_tables[index]._kv = kv;
			_tables[index]._state = EXIST;
			++_n;
			return true;
		}
		HashData* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi =key % _tables.size();
			//等于删除也往后找，防止有时候查找数据还删数据，如果判断为非存在就有问题了，过不去后面的数据
			size_t i = 1;
			size_t index = hashi;
			while (_tables[index]._state != EMPTY)
			{
				if (_tables[index]._kv.first == key
					&& _tables[index]._state == EXIST)//如果已经删了再找就找不到了
				{
					return &_tables[index];
				}
				index = i + hashi;
				index %= _tables.size();
				++i;
				if (index == hashi)//找了一圈，全是存在和删除
				{
					break;
				}
			}
			//有两可能，一个是index==hashi，找了一圈全是存在和删除，还有一种可能是一开始index=hashi的时候后面就没有数据了。
			return nullptr;
		}
		bool Erase(const K& key)
		{
			HashData* k = Find(key);
			if (k)
			{
				k->_state = DELETE;
				--_n;
					return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector> _tables;
		size_t _n = 0;
	};
}
namespace HashBucket
{
	template
	struct HashNode
	{
		HashNode* _next;
		T _data;
		HashNode(const T& data)
			:_data(data)
			,_next(nullptr){}
	};
	template
	class HashTable;
	template
	class _HashIterator
	{
	public:
		typedef HashNode Node;
		typedef HashTable HT;
		typedef _HashIterator Self;
		typedef _HashIterator iterator;

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

		_HashIterator(const iterator& it)
			:_node(it._node)
			,_ht(it._ht){}

		Ref operator*()
		{
			return _node->_data;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}
		bool operator!=(const Self& s)
		{
			return _node != s._node;
		}
		Self& operator++()
		{
			if (_node->_next != nullptr)
			{
				_node = _node->_next;
			}
			else
			{
				keyoft kot;
				size_t hashi = kot(_node->_data) % _ht->_tables.size();
				++hashi;
				while (hashi < _ht->_tables.size())
				{
					if (_ht->_tables[hashi])
					{
						_node = _ht->_tables[hashi];
						break;
					}
					else
					{
						++hashi;
					}
				}
				if (hashi == _ht->_tables.size())
				{
					_node = nullptr;
				}
				return *this;
			}
		}
			
	};
	template
	class HashTable
	{
	public:
		typedef HashNode Node;
		typedef _HashIterator _iterator;
		typedef _HashIterator const_iterator;
		template
		friend class _HashIterator;

		_iterator begin()
		{
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				cur = _tables[i];
				if (cur)
				{
					break;
				}

			}
			return _iterator(cur, this);
		}
		const_iterator begin()const
		{
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				cur = _tables[i];
				if (cur)
				{
					break;
				}

			}
			return _iterator(cur, this);
		}
		_iterator end()
		{
			return _iterator(nullptr, this);
		}
		const_iterator end()const
		{
			return _iterator(nullptr, this);
		}
		_iterator find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return end();
			}
			keyoft kot;
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return _iterator(cur, this);
				}
				cur = cur->_next;
			}
			return end();
		}
		~HashTable()
		{
			for (auto& e : _tables)
			{
				while (e)
				{
					Node* next = e->_next;
					delete e;
					e = next;
				}
				e = nullptr;

			}
		}
		bool Insert(const T& data)
		{
			keyoft kot;

			if (_n == _tables.size())
			{
				//扩容
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector newtables(newsize, nullptr);
				for (auto& cur : _tables)
				{
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = kot(cur->_data) % newtables.size();
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;
						cur = next;

					}
				}
				_tables.swap(newtables);
			}
			size_t hashi = kot(data) % _tables.size();
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}
		bool Erase(const K& key)
		{
			keyoft kot;
			size_t hashi = 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;
					return true;
				}
				else
				{
					_prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
	private:

		vector _tables;
		size_t _n = 0;
	};
}

2：unordered_map.h

template
class unordered__map
{
	struct mapoft
	{
		const K& operator()(const pair& kv)
		{
			return kv.first;
		}
	};
public:
	typedef typename HashBucket::HashTable, mapoft>::_iterator iterator;
	typedef typename HashBucket::HashTable, mapoft>::const_iterator const_iterator;

	bool Insert(const pair& kv)
	{
		return _ht.Insert(kv);
	}
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}
	iterator begin()
	{
		return _ht.begin();
	}
	iterator end()
	{
		return _ht.end();
	}
	
private:
	HashBucket::HashTable, mapoft> _ht;
};

 3：unordered_set

#include"HashTable.h"
template
class unordered__set
{
	struct setoft
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename HashBucket::HashTable, mapoft>::const_iterator iterator;
	typedef typename HashBucket::HashTable, mapoft>::const_iterator const_iterator;

	bool Insert(const pair& kv)
	{
		return _ht.Insert(kv);
	}
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}
	iterator begin()
	{
		return _ht.begin();
	}
	iterator end()
	{
		return _ht.end();
	}

private:
	HashBucket::HashTable, setoft> _ht;
};

4：讲解

K是用来find的时候使用的返回值，对于map来说不能没有。set可以没有，因为set是K K

V是上层传入的数据类型。

因为闭散列的哈希桶，如果迭代器++，有可能是在当前桶中遍历，也有可能是在vector中找下一个不为空的头节点，所以在迭代器中必须定义一个node和一个哈希桶指针ht。因为node里面不会存储下一个桶的地址。

迭代器要封装一个普通和const版本，对于set来说可以不需要普通迭代器，对于map来说则必须要，因为map的second可能会++。

 这里面如果set创建对象，是一个普通对象，普通对象return的是普通迭代器，但是函数返回值是const迭代器，所以这里就有从普通迭代器->const迭代器的转换。

还记得单参的构造函数可以隐式类型转换吗？ 

在迭代器里面我们定义了iterator是一个普通迭代器，因此我们想用普通迭代器转换为const迭代器，意思就是用普通迭代器去构造一个const迭代器。

对于开散列的插入，我们可以复用自己的insert，对于闭散列，不要浪费原来的节点，插入新节点就行了。

keyoft是一个仿函数，因为底层hashtable并不清楚V是什么类型，所以上层通过传入（pair和k）不同的类型，来返回到first或者k本身。

operator[]我这里没有实现，实现思路是让底层insert的返回值为pair，第一步是用map里面的pair ret接收insert的返回值，这样既能插入，又可以判断是否已经存在这个值，然后返回ret的first的second，比如我们排序的时候会用m[e]++,就是这个意思

实际上map这一层还会多一个参数hashfunc，比较一下map和unordered_map，要满足V能成为映射值，也就是可以取整，所以需要设计一个string类的转化为size_t的仿函数。

  实际上针对扩容问题有一个更好的方案，让每次扩容的容量为质数。可以减少冲突

			static const unsigned long __stl_prime_list[__stl_num_primes] =
			{
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};