理解底层结构

unordered_map和unordered_set底层采用的是哈希桶的数据结构，说白了就是一个指针数组。每个数组单位称为一个桶，这个桶就是一个结点单链表。通过哈希散列函数映射到数组中的具体某个位置后，将数据形成一个新的桶结点插入进单链表。

模拟实现hashtable就是实现一个维护指针数组的类。

namespace HASH_BUCKET
{
    
	template<class K, class V, class Hash, class GetKey>
	class HashTable;//前置声明
	//K:键值
	//V:值
	//Hash:hash函数
	//GetKey:根据V获取key

	template<class T>
	struct HashNode
	{
    
		HashNode(const T& val)
			:_data(val)  
		{
    }
		HashNode<T>* next = nullptr;
		T _data;
	};


	template<class K, class V, class Hash, class GetKey>
	class HashTableIterator
	{
    
		typedef typename HashTableIterator<K, V, Hash, GetKey> iterator;
		typedef typename HashNode<V> Node;
		typedef typename HashTable<K, V, Hash, GetKey> Table;
	public:
		HashTableIterator(Node* node, Table* table)
			:elem(node), _ptable(table)
		{
    }
		iterator operator++()
		{
    
			//1.判断当前桶后面是否还有元素
			Node* cur = elem->next;
			if (!cur)
			{
    
				int index = get_key(elem->_data);
				while (!cur&&++index < _ptable->_hashtable.size())
					cur = _ptable->_hashtable[index];
			}
			elem = cur;
			return *this;
		}
		V& operator*() const
		{
    
			return elem->_data;
		}
		V* operator->() const
		{
    
			return &(operator*());
		}
		
	private:
		Node* elem;
		Table* _ptable;
	};

	template<class K, class V, class Hash, class GetKey>

	class HashTable
	{
    
		typedef typename HashTableIterator<K, V, Hash, GetKey> iterator;
		typedef typename HashNode<V> Node;

		GetKey get_key;
	public:
		pair<iterator, bool> Insert(const V& _kv)
		{
    
			//判断是否需要新表
			if (_dataNum == _hashtable.size())
			{
    
				HashTable newTable;
				int newSize = _hashtable.size() == 0 ? 10 : _hashtable.size() * 2;
				newTable._hashtable.resize(newSize);
				for (int i = 0; i < _hashtable.size(); ++i)
				{
    
					Node* cur = _hashtable[i];
					while (cur)
					{
    
						newTable.Insert(cur->_data);
						newTable._dataNum++;
						cur = cur->next;
					}
				}
				_hashtable.swap(newTable._hashtable);
			}
			//为待插入元素初始化并开辟空间，源码用的是alloc
			Node* newNode = new Node(_kv);
			//判断插入bucket number
			size_t key = get_key(_kv);
			int index = HashFunc(key, _hashtable.size());
			//头插
			Node* head = _hashtable[index];
			while (head)
			{
    
				if (get_key(head->_data) == get_key(_kv))
				{
    
					iterator it(head, this);
					return make_pair(it, false);
				}
				head = head->next;
			}

			newNode->next = _hashtable[index];
			_hashtable[index] = newNode;

			++_dataNum;
			iterator it(newNode, this);
			return make_pair(it, true);
		}
		iterator Find(const K& key)
		{
    
			int index = HashFunc(key, _hashtable.size());
			Node* cur = _hashtable[index];
			while (cur)
			{
    
				if (get_key(cur->_data) == key)
					return iterator(cur,this);
				++cur;
			}
			return end();
		}
		bool Erase(K& key)
		{
    
			int index = HashFunc(key, _hashtable.size());
			Node* cur = _hashtable[index];
			Node* prev = cur;
			while (cur)
			{
    
				if (get_key(cur->_data) == key)
				{
    
					if (cur == _hashtable[index])
						_hashtable[index] = nullptr;
					else
						prev->next = cur->next;
					delete cur;
					return true;
				}
				prev = cur;
				cur = prev->next;
			}
			return false;
		}
		bool Erase(iterator& it)
		{
    
			K key = get_key(it.elem->_data);
			return Erase(key);
		}
		iterator& operator [](const K& key)
		{
    
			if (_hashtable[get_key(key)] != nullptr)
				return iterator(_hashtable[get_key(key)], this);
			else
				return end();
		}
		//哈希散列函数
		size_t HashFunc(const K& key, size_t size)
		{
    
			Hash hash;
			return hash(key) % size;
		}
		iterator begin()
		{
    
			for (int i = 0; i < _hashtable.size(); i++)
				if (_hashtable[i])
					return iterator(_hashtable[i], this);
			return end();
		}
		iterator end()
		{
    
			return iterator(0, this);
		}
		void clear()
		{
    
			for (int i = 0; i < _hashtable.size(); i++)
			{
    
				while (_hashtable[i])
				{
    
					cur = _hashtable[i];
					_hashtable[i] = cur->next;
					delete cur;
				}
			}
		}
	private:
		vector<Node*> _hashtable;
		//记录当前哈希桶中数据个数。
		size_t _dataNum = 0;
	};
}

模拟实现unordered_set

namespace lei
{
    
	template<class K, class V, class Hash = _Hash<K>, class GetKey = _Select<pair<K, V>>>
	class unordered_set;//前置声明

	template<class V>
	struct _Select
	{
    
		size_t operator()(const V& value)
		{
    
			return value;
		}
	};
	template<class K>
	struct _Hash
	{
    
		size_t operator()(const K& key)
		{
    
			return key;
		}
	};
	template<>
	struct _Hash<string>
	{
    
		size_t operator()(const string& str)
		{
    
			int sum = 0;
			for (int i = 0; i < str.size(); i++)
			{
    
				sum = sum + sum * 131 + str[i];
			}
			return sum;
		}
	};

	template<class K,  class Hash = _Hash<K>, class GetKey = _Select<K>>
	class unordered_set
	{
    
	public:
		typedef HASH_BUCKET::HashTable<K, pair<K, K>, Hash, GetKey> HashSet;
		typedef typename HASH_BUCKET::HashTableIterator < K, pair<K, K>, Hash, GetKey> Iterator;

	public:
		size_t size() const
		{
    
			return _set._dataNum;
		}
		size_t bucket_count() const
		{
    
			return _set._hashtable.size();
		}
		bool empty() const
		{
    
			return _set._dataNum == 0;
		}
		Iterator begin()
		{
    
			return _set.begin();
		}
		Iterator end()
		{
    
			return _set.end();
		}

		pair<Iterator, bool> insert(const pair<K, K>& _kv)
		{
    
			return _set.Insert(_kv);
		}
		bool erase(const K& key)
		{
    
			return _set.Erase(key);
		}
		bool erase(Iterator& it)
		{
    
			return _set.Erase(it);
		}
		void clear()
		{
    
			return _set.clear();
		}
	private:
		HashSet _set;
	};
}

模拟实现unordered_map

namespace lei
{
    
	template<class K, class V, class Hash = _Hash<K>, class GetKey = _Select<pair<K, V>>>
	class unordered_map;//前置声明

	template<class V>
	struct _Select
	{
    
		size_t operator()(const V& value)
		{
    
			return value.first;
		}
	};
	template<class K>
	struct _Hash
	{
    
		size_t operator()(const K& key)
		{
    
			return key;
		}
	};
	template<>
	struct _Hash<string>
	{
    
		size_t operator()(const string& str)
		{
    
			int sum = 0;
			for (int i = 0; i < str.size(); i++)
			{
    
				sum = sum + sum * 131 + str[i];
			}
			return sum;
		}
	};

	template<class K, class V, class Hash = _Hash<K>, class GetKey = _Select<pair<K,V>>>
	class unordered_map
	{
    
	public:
		typedef HASH_BUCKET::HashTable<K, pair<K,V>, Hash, GetKey> HashMap;
		typedef typename HASH_BUCKET::HashTableIterator < K, pair<K, V>, Hash, GetKey> Iterator;

	public:
		size_t size() const
		{
    
			return _map._dataNum;
		}
		size_t bucket_count() const
		{
    
			return _map._hashtable.size();
		}
		bool empty() const
		{
    
			return _map._dataNum == 0;
		}
		Iterator begin()
		{
    
			return _map.begin();
		}
		Iterator end()
		{
    
			return _map.end();
		}

		pair<Iterator, bool> insert(const pair<K, V>& _kv)
		{
    
			return _map.Insert(_kv);
		}
		bool erase(const K& key)
		{
    
			return _map.Erase(key);
		}
		bool erase(Iterator& it)
		{
    
			return _map.Erase(it);
		}
		void clear()
		{
    
			return _map.clear();
		}
	private:
		HashMap _map;
	};
}