C++基础学习——哈希表的封装

目录

​编辑

一，实现一个可封装的哈希表

1，哈希表的节点

 2，哈希表的成员

 3，哈希表成员方法的实现

 4，迭代器的实现

 5，在哈希表中加入迭代器

二，封装哈希表

1，unorder_map封装

2，unordered_set的封装

 

---

一，实现一个可封装的哈希表

1，哈希表的节点

在哈希表的封装中，分为两类：unordered_map,unordered_set。其中map的元素类型为pair<K,V>类型，set的类型为K类型。

Node实现如下：

   template<class T>
	struct Node
	{
		Node<T>* _next;
		T val;
	};

 2，哈希表的成员

哈希表的成员有两个，一个是记录哈希表节点个数的成员_n，一个是成员为Node*类型的vector<Node*>数组。

HashTable实现如下：

template<class T>
	class HashTables
	{
		typedef Node<T> Node;
	public:

	private:
		vector<Node*>_tables;
		size_t _n;
	};

 3，哈希表成员方法的实现

（1），Find(V&key)方法

Find方法实现的是在一个哈希表中寻找某个值存不存在。步骤如下：1，找到这个值对应的hashi（在哈希表中的下标）。2，遍历这个下标上挂载的链表上是否有该值。3，有则返回true,没有就返回false.

要找到hashi: 先实现两个方法Getkey()与GetHashi()

Getkey()：

    template <class K,class V>
	struct Getkey
	{
		K operator()(const V& val)//一般的成员直接返回val,遇到特殊pair类型的则返回val.first(先不实现)
		{
			return val;
		}
	};

 GetHashi()：

template <class T>//一般情况下
	struct GetHashi
	{
		size_t operator(T& val)
		{
			return (size_t)val;
		}
	};

	template<>//模板特化，当这个成员的类型为string类型时
	struct GetHashi<string>
	{
		size_t operator()(string& val)
		{
			size_t ret = 0;
			for (int i = 0;i < val.size();i++)
			{
				ret += ret * 31 + val[i];
			}

			return ret;
		}
	};

Find():

       bool Find(V& val)
		{
			size_t hashi = GetHashi(Getkey(val)) % _tables.size();//计算hashi

			Node* cur = _tables[hashi];//找到对应的位置上的链表
			while (cur)//开始寻找
			{
				if (cur->val == _val) return true;
			}

			return false;

		}

（2），Insert（T&key）

 实现插入函数：(1)，满载时要扩容，扩容逻辑是创建一个新的vector<Node*>temp并且把这个表的大小扩为旧表的二倍。 (2)，将旧表中的元素拆下来头插到新表中。（3），将就表中的值全部变为nullptr,防止二次析构。（4），将新表交换给旧表

Insert函数代码： 

bool Insert(const V& val)
		{
			if (Find(val)) return false;//存在过则直接返回插入失败

			if (_n == _tables.size())//检查是否需要扩容
			{
				int newsize = 2*(_n == 0? 1 : _n);//新的大小
				
				vector<Node*>temp;//开一个临时数组
				temp.resize(newsize);//扩大为原来哈希表的二倍

				for (int i = 0;i < _tables.size();i++)
				{
					Node* cur = _tables[i];
					Node* next = nullptr;
					if (cur)
					{
						while (cur)
						{
							size_t hashi = GetHashi(Getkey(cur->_val))%_tables.size();//计算新的哈希值
							//保存下一个值，并更新就哈希表上的值
							next = cur->_next;
							_tables[i] = next;

							//头插到新的哈希表中
							cur->_next = temp[hashi];
							temp[hashi] = cur;

							cur = next;
						}
					}
				}

				//扩容好后便夺回来
				for (int i = 0;i < _tables.size();i++)
				{
					_tables[i] = nullptr;
				}

				_tables.swap(temp);

			}

			int hashi = GetHashi(Getkey(val))%_tables.size();
			Node* newNode = new Node(val);

			//头插
			newNode->_next = _tables[hashi];
			_tables[hashi] = newNode;

			_n++;
			return true;

		}

 （3）Erase(V&val)

实现：先找到这个值，再删除。

Erase（V&val）代码：

       bool Erase(const V& val)
		{
			int hashi = GetHashi(Getkey(val)) % _tables.size();//计算hashi
			Node* pre = nullptr;//记录hashi前面的指针
			Node* cur = _tables[hashi];//当前指针

			while (cur)
			{
				if (cur->_val == val)//有相同的便开始执行删除逻辑
				{
					if(pre)pre->_next = cur->_next;//加上条件防止头删出错
					delete cur;
					cur = nullptr;
					_n--;
					return true;
				}

				pre = cur;
				cur = cur->_next;
			}

			return false;

		}

 4，迭代器的实现

（1），迭代器的成员

迭代器的成员：1，一个Node*类型的成员_node（因为迭代器就是一种模拟指针的行为所以要有哈希表元素的指针）。2，哈希表的指针和当前的_node对应的位置（主要是为了方便实现++）。

代码如下：

        typedef HTiterator<K, V, ref, ptr, Getkey, GetHashi> self;//迭代器类型
		typedef Node<V> Node;
		Node* _node;//哈希表成员的指针
	    typedef HashTables<K, V, Getkey, GetHashi>*  pht;
		pht _pht;//哈希表的指针
		size_t _hashi;//迭代器在哈希表中的位置

（2）迭代器++的实现

1，找到下一个不为nullptr的点（这里要用到哈希表的指针和当前指针的位置） 。  2，返回一个迭代器。3，在实现++之前得实现一个迭代器的构造函数。

构造函数代码：

        HTiterator(Node* node,pht Hp,size_t hashi)//构造函数
			:_node(node)
			,_pht(Hp)
			,_hashi(hashi)
		{}

实现迭代器operator++()代码：

//实现++
		self operator ++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
			
				_hashi++;
				while (_hashi < _pht->_tables.size())
				{
					if (_pht->_tables[_hashi])
					{
						_node = _pht->_tables[_hashi];
						return HTiterator(_node, _pht, _hashi);//找到了直接返回构造的iterator
					}
					_hashi++;
				}
				_node = nullptr;//找不到就将_node置为nullptr在构造
				
			}

			return  HTiterator(_node, _pht, _hashi);
		}

（3）实现operator*()，operator->(),operator!=()

*:返回值是_node里面的val。->:返回值是_node->val的地址。！=：比较的是_node

 代码：

        ref operator*()
		{
			return _node->_val;
		}

		ptr operator->()
		{
			return& _node->_val;
		}

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

 5，在哈希表中加入迭代器

       typedef HTiterator<K, V, V&, V*> iterator;//定义一个迭代器类型

		iterator begin()//实现begin()
		{
			for (int hashi = 0;hashi < _tables.size();hashi++)
			{
				if (_tables[hashi]) return iterator(_tables[hashi], this, hashi);
			}

			return end();
		}

		iterator end()//实现end()
		{
			return iterator(nullptr, this, -1);
		}

二，封装哈希表

1，unorder_map封装

(1)unordered_map的成员

unordered_map的底层便是一个哈希表，所以unordered_map的成员便是一个哈希表。

代码：

cq::HashTables<K,pair<K, V>, Getkey<K,V>> HT;

（2）unordered_map的方法

在实现这些方法之前，先得把哈希表里的Insert()和Find()方法的返回值改一下，改成如下形式：pair<iterator,bool>，方便后面的operator[]的实现。

代码：

pair<iterator,bool> Insert(const V& val)//改成pair<iterator,bool>类型
		{
			iterator it = Find(val);
			if (it != end()) return make_pair(it, false);

			if (_n == _tables.size())//检查是否需要扩容
			{
				int newsize = 2*(_n == 0? 1 : _n);//新的大小
				
				vector<Node*>temp;//开一个临时数组
				temp.resize(newsize);

				for (int i = 0;i < _tables.size();i++)
				{
					Node* cur = _tables[i];
					Node* next = nullptr;
					if (cur)
					{
						while (cur)
						{
							size_t hashi = GetHashi(Getkey(cur->_val))%_tables.size();//计算新的哈希值
							//保存下一个值，并更新就哈希表上的值
							next = cur->_next;
							_tables[i] = next;

							//头插到新的哈希表中
							cur->_next = temp[hashi];
							temp[hashi] = cur;

							cur = next;
						}
					}
				}

				//扩容好后便夺回来
				for (int i = 0;i < _tables.size();i++)
				{
					_tables[i] = nullptr;
				}

				_tables.swap(temp);

			}

			size_t hashi = GetHashi(Getkey(val))%_tables.size();
			Node* newNode = new Node(val);

			//头插
			newNode->_next = _tables[hashi];
			_tables[hashi] = newNode;

			_n++;
			return   make_pair(iterator(newNode, this, hashi),true);

		}

（2） 实现V& operator[](K&key)

operator[]的作用是让我们能够通过key值来访问val值。

代码：

       V& operator[](const K& key)
		{
			pair<iterator,bool> ret = HT.Insert(make_pair(key,V()));
			return  ret.first->second;//返回的是一个pair<iterator,bool>,first代表iterator，然后再调用iterator的->找到val值
		}

（3）unordered_map里其它的成员方法

其它的成员方法都是通过调用哈希表里面实现的方法实现的。

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

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

		pair<iterator, bool> insert(const pair<K,V>& val)
		{
			return HT.Insert(val);
		}

		bool erase(const V& val)
		{
			return HT.Erase(val);
		}

		pair<iterator,bool> Find(const V& val)
		{
			return HT.Find(val);
		}

unordered_map封装代码：

	template < class K,class V>
	struct Getkey
	{
		K operator()(const pair<K,V>& val)
		{
			return val.first;
		}
	};

	template <class K, class V>
	class my_unordered_map
	{
		typedef typename cq::HashTables<K, pair<K,V>, Getkey<K,V>>::iterator iterator;

	public:
		iterator begin()
		{
			return HT.begin();
		}

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

		pair<iterator, bool> insert(const pair<K,V>& val)
		{
			return HT.Insert(val);
		}

		bool erase(const V& val)
		{
			return HT.Erase(val);
		}

		pair<iterator,bool> Find(const V& val)
		{
			return HT.Find(val);
		}

		V& operator[](const K& key)
		{
			pair<iterator,bool> ret = HT.Insert(make_pair(key,V()));
			return  ret.first->second;
		}


	private:
		cq::HashTables<K,pair<K, V>, Getkey<K,V>> HT;


	};

 

2，unordered_set的封装

unordered_set的封装与unordered_map的封装类似。但是不用实现operator[]。

 代码如下：

	template < class K>//set的模板参数只要一个
	struct Getkey
	{
		K operator()(const K& val)
		{
			return val;
		}
	};

	template <class K>
	class my_unordered_set
	{
		typedef typename cq::HashTables<K, K, Getkey<K>>::iterator iterator;

	public:
		iterator begin()
		{
			return HT.begin();
		}

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

		pair<iterator, bool> insert(const K& val)
		{
			return HT.Insert(val);
		}

		bool erase(const K& val)
		{
			return HT.Erase(val);
		}

		pair<iterator, bool> Find(const K& val)
		{
			return HT.Find(val);
		}


	private:
		cq::HashTables<K, K, Getkey<K>> HT;//内部成员哈希表


	};