C++ 哈希表实现

不管你所给到的函数是什么样子的，都只可能尽量减少哈希冲突，不可完全避免哈希冲突，因此当发生哈希冲突的时候，我们应该如何处理呢？

1.线性探测法（hashi + i (i>=0)）

当你想存放的位置存在数据时，就存放在当前位置的下一个，如果下一个位置也有数据，就存放在下一个的下一个，直到没有数据为止。

2.二次探测法 (hashi + $i^{2}$ (i>=0))

当你想存放的位置存在数据时，存放在 $i^{2}$ 的位置，i为1就是hashi+1，i为2就是hashi+4，因此类推，直到没有数据为止。

后续还有n次探测等等

2.开放定制法实现

2.1类的参数

首先定义一个枚举代表当前位置的状态，状态有 空、存在、删除。为什么要有这三个，而不是存在和不存在。主要是为了如下情况

当我们依次插入23,13,33,34。线性探测存值如下所示。

当我们删除13时。如果只有存在和不存在，那么我们后续就找不到33和34了，因为找到空（不存在）就会停止。

什么？你说不停止继续找？如果不停止，那我搞个哈希表和线性表有什么区别，那时间复杂度还是O（1）吗？

因此我们需要 空、存在、删除三个状态，保证我们遇到删除状态后，能够继续往后寻找。哈希表_tables存放的内容为HashDate，这里使用库里面的vector帮助我们完成哈希表。同时还需要一个长度_n，代表存放了多少个值，如果_n / _tables.size() 的结果达到我们设定的某个值（比如百分之70），这个值我们称做负载因子，达到这个限制值后，如果再插入结点会发生很多的哈希冲突，因此我们需要扩容。

正因为负载因子的存在，就算发生了哈希冲突，我们也能较容易的找到下一个该存放的位置。

enum Status
{
	EMPTY,
	EXIST,
	DELETE,
};

template<class K, class V>
struct HashDate
{
	pair<K, V> _kv;
	Status _s;
};
template<class K,class V>
class HashTable
{
private:
	vector<HashDate<K,V>> _tables;
	size_t _n;
};

2.2类的构造

构造很简单，我们想让哈希表初始化的时候，帮我们开辟好变量 vector<HashDate<K,V>> _tables 的空间，那么我们调用resize()函数帮助我们开辟空间即可。

HashTable()
{
	_tables.resize(10);
}

2.3查找实现

首先，传入的参数毫无疑问，肯定是key，通过key值判断该值在不在哈希表中。

然后算出key经过哈希函数转化后的值，记为hashi。这个hashi就是我们映射在_tables表里的索引。

我们开始判断是否为空，为空就证明没找到该数据。

不为空，就判断该位置存放的_kv模型的first是否与key值相等，同时判断条件还得加上该位置不能为删除。（为什么要判断是否为删除，因为我们删除函数先找到后，就将他的状态设置为DELETE，并没有重置数据，我们也不知道该将数据重置为什么）

找到了，就范围该位置的地址，不然就线性探测，++hashi往后寻找，代码hashi %= _tables.size();是为了防止越界，发生越界就会回到表的索引0处。直到状态为空结束。

代码部分如下

HashDate<K,V>* Find(const K& key)
{
	size_t hashi = key % _tables.size();
	while (_tables[hashi]._s != EMPTY)
	{
		if (_tables[hashi]._s != DELETE && _tables[hashi]._kv.first == key)
			return &_tables[hashi];
		hashi++;
		hashi %= _tables.size();
	}
	return nullptr;
}

2.4插入实现

插入的参数是pair模型。

先查看在不在，在就返回false。代表已存在，不能插入了。

依然是先算哈希值，存在就找下一个，为空或者为DELETE我们都选择插入，将状态修改为存在，++_n。

bool Insert(const pair<K,V>& kv)
{
	if (Find(kv.first))
	{
		return false;
	}

	size_t hashi = kv.first % _tables.size();
	while (_tables[hashi]._s == EXIST)
	{
		hashi++;
		hashi %= _tables.size();
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._s = EXIST;
	++_n;

	return true;
}

我们还差一些东西，比如扩容，当 _n / _tables.size()大于等于负载因子时，需要扩容，代码部分添加到Find函数后面，因为找到该值就会返回，不需要扩容。

判断条件就跟负载因子有关，_n / _tables.size()就是我们的负载因子，由于这两个都是整数，因此我们表达式的前后都乘了10。当前的负载因子为0.7。

这里我们选择用了更方便的写法，建立了一个新的哈希表newht，将size()开辟为之前的两倍，遍历复用插入，当我们遍历插入完毕后，新哈希表newht的_tables就是我们现在的_tables想要的内容，由于_tables是vector，因此我们调用一下swap就好了。

if (_n*10 / _tables.size() >= 7)
{
	int newcapacity = _tables.size() * 2;
	HashTable<K, V> newHT;
	newHT._tables.resize(newcapacity);
	for (size_t i = 0; i < _tables.size(); i++)
	{
		if(_tables[i]._s == EXIST)
		{
			newHT.Insert(_tables[i]._kv);
		}
	}
	_tables.swap(newHT._tables);
}

我们运行测试一下，没问题。（打印代码不用管，只是方便我们查看，后面会给出，）

2.5删除实现

使用代码复用，通过Find函数找到该key存放的位置。

找到了就将状态置为DELETE，--_n，返回true，没找到就返回false。

bool Erase(const K& key)
{
	HashDate<K, V>* ret = Find(key);
	if (ret)
	{
		ret._s = DELETE;
		--_n;
		return true;
	}
	return false;
}

测试一下

2.6string做key

之前我们分析的都是整形来做key，自然而然就可以用除法去找到索引，那么string类型呢？在生活中string类型做key可是非常常见的。

这里我们选择添加一个模板参数，并且是缺省的，这个参数的目的就是利用仿函数将支持强转size_t类型的key转成size_t类型，对于其他类型，我们也可以通过一些方法转成size_t类型。

我们针对string类型使用了模板特化，当发现key为string时就会走该函数，因为特化是现成的代码，而上面那个还需要去推演出来类型。

至于为什么我们代码的sum要*31，这是防止哈希冲突。

如果不处理，如“abc”和“acb”还有“bbb”就会发生哈希冲突，具体可以看大佬的文章字符串Hash函数

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t sum = 0;
		for (auto& e : s)
		{
			sum *= 31;
			sum += e;
		}
		return sum;
	}
};
template<class K,class V ,class Hash = HashFunc<K>>
class HashTable
{
    //相关代码
};

修改一下，在我们所有要对key变成整数的地方都套上一层，这里只套了一个，明白意思就好。

测试一下代码，由于我们特化了string，并且HashTable第三个模板参数为缺省参数，因此这里可以不传参，如果你的key是自定义类型，那么你需要自己写哈希函数并传参。

四、哈希桶（开散列）

1.开散列概念

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中

开放定制法如下图所示的图片

同样的数据，放在哈希桶如下，就像拉链一样，一个挂着一个。

那么哈希桶的优势在哪里呢？我们可以发现，当我们去寻找4和14这种数据，似乎区别不大。

但是一旦我们寻找54，差距就大了，开放定制法会一直找到9的后面才结束，而哈希桶只需要将当前挂载的链表找完就可以了。

再比如我们寻找9，开放定制法会一直找到9才结束，而哈希桶一下就找到了。

在Java JDK1.8版本中，如果某个链表长度超过了8，会选择挂载红黑树，增加效率，C++还没有这样做，至于为什么，我们在实现中会测试，大家一起往下看吧。

2.开散列实现

2.1类的参数

我们的_tables里面存放的是结点，为什么不用库里面的list呢？

首先，我们只需要单向链表即可，要用也是用库里面的forward_list(单向链表)，其次，使用库里面的链表会让我们后续封装迭代器更加麻烦，最后，使用自己手写结点也很简单，因此选择自己写一个。

HashNode存放_kv和_next，并且写出了构造函数，方便我们new结点。

template<class K, class V>
struct HashNode
{
	pair<K, V> _kv;
	HashNode<K, V>* _next;
	HashNode(const pair<K,V>& kv)
		:_kv(kv)
		,_next(nullptr)
	{}
};

template<class K, class V>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
    HashTable()
    {
	    _tables.resize(10);
    }
private:
	vector<Node*> _tables;
	size_t _n;
};

2.2类的构造函数

1.默认构造给_tables开辟十个空间。

2.拷贝构造我们也要自己写，需要深拷贝，选择头插，老生常谈的东西了。

3.operator= 赋值拷贝，传参选择不传&，这样就会发生拷贝构造，同时不传const，因为我们析构后会删除。再调用swap函数即可，将别人的交换一下，出了作用域自动调用析构函数。

4.析构函数遍历加一个个节点删除即可。

HashTable()
{
	_tables.resize(10);
}
HashTable(const HashTable<K,V>& ht)
{
	_tables.resize(ht._tables.size(), nullptr);
	for (size_t i = 0; i < ht._tables.size(); i++)
	{
		Node* cur = ht._tables[i];
		while (cur)
		{
			Node* newnode = new Node(cur->_kv);
			if (_tables[i]==nullptr)
			{
				_tables[i] = newnode;
			}
			else
			{
				newnode->_next = _tables[i];
				_tables[i] = newnode;
			}
			cur = cur->_next;
		}
	}
}

HashTable<K, V>& operator=(HashTable<K, V> ht)
{
	_tables.swap(ht._tables);
	swap(_n, ht._n);
	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;
	}
}

2.3查找实现

一样先计算哈希值hashi，通过hashi去找到存放在_tables里面的结点，结点不为空，就证明该节点存放了链表，便开始遍历链表，找到就返回结点，没找到就一直找，直到为空。

Node* Find(const K& key)
{
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return nullptr;
}

2.4插入实现

开散列的插入大致思路跟开放定制法一样，先查找，在判断负载因子，最后插入。

我们先来看插入部分，先计算映射的哈希值hashi，再new一个新节点，将新节点的_next指向hashi的地址，再将新节点复制给hashi，这样就完成了头插，最后++_n。具体插入如下图所示，newnode为11

对于扩容部分，由于是拉链法，负载因子可以适当大一点，因此我们将负载因子调整到了1，也就是_n==_tables.size()。并且我们并没有像开放定制法那样复用Insert，因为复用insert又会开辟新结点，并且析构函数需要自己写，因为HashNode是自定义类型，并且有指针。这样析构起来速度会很慢，因此我们选择将原来_tables上的结点直接挪动过来，这样也节省了开辟结点和析构结点的时间。

代码部分新创建一个newtables，先开辟原哈希表2倍的大小，遍历原哈希表，将挂载的索引节点重新映射到新表上，依然选择的头插法。当当前链表遍历完毕后，要将_tables[i]置空，因为这是浅拷贝，不置空析构会有问题。最后swap一下即可。

bool Insert(const pair<K, V>& kv)
{
	if (Find(kv.first))
		return false;
	if (_n == _tables.size())
	{
		vector<Node*> newtables;
		newtables.resize(_tables.size() * 2, nullptr);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				//映射到新表
				size_t hashi = cur->_kv.first % newtables.size();
				cur->_next = newtables[hashi];
				newtables[hashi] = cur;
				cur = next;
			}
			//置空，防止析构出现问题
			_tables[i] = nullptr;
		}
		_tables.swap(newtables);
	}
	size_t hashi = kv.first % _tables.size();
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

运行打印，看看效果，没问题。

2.5 删除实现

这里我们没有用Find来删除，因为就算我们找到了结点，由于是单链表，我们也无法找到节点的前一个，因此没有用Find函数。

取出哈希值hashi，遍历当前的哈希值的链表，同时记录好前一个。找到Key或者找到空结束，如果找到了，而且前一个为空，证明删除的是第一个，就直接将cur->_next给到_tables[hashi]即可，完成头删。

如果前一个不为空，则不是头删，则prev->_next = cur->_next; 最后detele 再return true即可。

bool Erase(const K& key)
{
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	Node* prev = nullptr;
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (prev == nullptr)
			{
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			delete cur;

			return true;
		}

		prev = cur;
		cur = cur->_next;
	}
	return false;
}

测试一下

2.6string做key

依然是我们之前写的HashFund，在本文的三、2.6

需要取整数的地方套上一层就可以了。不多赘述。

五、哈希桶与set和unordered_set的对比

这里我们选取了一百万个随机值进行插入测试，（具体打印函数后续会给出）根据打印内容我们发现，哈希表处理数据的速度是要比红黑树快一点的。

至于之前我们说为什么C++不适用哈希表挂载红黑树的方式，我们可以通过maxBucketLen来知道，一个地方时很难挂载到很多数据的，除非你是人为恶心哈希表才会挂载很多数据。

最后为什么我们的哈希表比库里面的还要快，因为库里面还涉及到了一些东西，我们写的是简单版。

最后附上代码

HashTable.h

#pragma once
#include<vector>

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t sum = 0;
		for (auto& e : s)
		{
			sum *= 31;
			sum += e;
		}
		return sum;
	}
};
namespace kky_open_address
{
	enum Status
	{
		EMPTY,
		EXIST,
		DELETE,
	};
	
	template<class K, class V>
	struct HashDate
	{
		pair<K, V> _kv;
		Status _s;
	};

	template<class K,class V ,class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
		{
			_tables.resize(10);
		}
		Hash hs;

		HashDate<K,V>* Find(const K& key)
		{
			size_t hashi = hs(key) % _tables.size();
			while (_tables[hashi]._s != EMPTY)
			{
				if (_tables[hashi]._s != DELETE && _tables[hashi]._kv.first == key)
					return &_tables[hashi];
				hashi++;
				hashi %= _tables.size();
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashDate<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_s = DELETE;
				--_n;
				return true;
			}
			return false;
		}

		bool Insert(const pair<K,V>& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n*10 / _tables.size() >= 7)
			{
				int newcapacity = _tables.size() * 2;
				HashTable<K, V> newHT;
				newHT._tables.resize(newcapacity);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if(_tables[i]._s == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);
			}

			size_t hashi = hs(kv.first) % _tables.size();
			while (_tables[hashi]._s == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._s = EXIST;
			++_n;

			return true;
		}
		
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._s == EXIST)
				{
					//printf("[%d]->%d:%s\n", i,_tables[i]._kv.first, "EXIST");
					cout << "[" << i << "]->" << _tables[i]._kv.first<<":" << _tables[i]._kv.second << endl;
				}
				else if(_tables[i]._s == EMPTY)
				{
					//printf("[%d]->%d:%s\n", i, _tables[i]._kv.first, "EMPTY");
					cout << "[" << i << "]->" <<endl;
				}
				else
				{
					//printf("[%d]->%d:%s\n", i, _tables[i]._kv.first, "DELETE");
					cout << "[" << i << "]->" <<"DELETE" << endl;
				}
			}
			cout << endl;
		}

	private:
		vector<HashDate<K,V>> _tables;
		size_t _n;
	};

	void test01()
	{
		HashTable<int, int> ht;
		int arr[] = { 3,13,23,4,5,14,7,13 };
		for (auto e : arr)
		{
			ht.Insert(make_pair(e, e));
		}
		ht.Print();
		ht.Erase(13);
		ht.Print();
		ht.Insert(make_pair(33,33));
		ht.Print();
	}
	void test02()
	{
		string arr[] = { "香蕉","苹果","橘子","香蕉","苹果" ,"香蕉","苹果" ,"香蕉" };
		HashTable<string, int> ht;
		for (auto e : arr)
		{
			HashDate<string, int>* ret = ht.Find(e);
			if(ret)
				ret->_kv.second++;
			else
				ht.Insert(make_pair(e, 1));
		}
		ht.Print();
	}
}

namespace kky_hash_bucket
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		HashNode(const pair<K,V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_tables.resize(10);
		}
		HashTable(const HashTable<K,V>& ht)
		{
			_tables.resize(ht._tables.size(), nullptr);
			for (size_t i = 0; i < ht._tables.size(); i++)
			{
				Node* cur = ht._tables[i];
				while (cur)
				{
					Node* newnode = new Node(cur->_kv);
					if (_tables[i]==nullptr)
					{
						_tables[i] = newnode;
					}
					else
					{
						newnode->_next = _tables[i];
						_tables[i] = newnode;
					}
					cur = cur->_next;
				}
			}
		}

		HashTable<K, V>& operator=(HashTable<K, V> ht)
		{
			_tables.swap(ht._tables);
			swap(_n, ht._n);
			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;
			}
		}

		bool Insert(const pair<K, V>& kv)
		{
			Hash hs;
			if (Find(kv.first))
				return false;
			if (_n == _tables.size())
			{
				vector<Node*> newtables;
				newtables.resize(_tables.size() * 2, nullptr);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						//映射到新表
						size_t hashi = hs(cur->_kv.first) % newtables.size();
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;
						cur = next;
					}
					//置空，防止析构出现问题
					_tables[i] = nullptr;
				}
				_tables.swap(newtables);
			}
			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}

		Node* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				cout << "[" << i << "]" << "挂载"<<"->";
				while (cur)
				{
					cout << cur->_kv.first << ":" << cur->_kv.second << "->";
					cur = cur->_next;
				}
				cout << endl;
			}
			cout << endl;
		}

		void Some()
		{
			size_t bucketSize = 0;
			size_t maxBucketLen = 0;
			double averageBucketLen = 0;

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

				size_t bucketLen = 0;
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}


				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}

			averageBucketLen = (double)bucketSize / (double)_n;

			printf("all bucketSize:%d\n",_tables.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}

	private:
		vector<Node*> _tables;
		size_t _n;
	};
	void test01()
	{
		HashTable<int, int> ht;
		int arr[] = { 3,13,23,4,5,14,33,34,43,44 };
		for (auto e : arr)
		{
			ht.Insert(make_pair(e, e));
		}
		ht.Print();
		cout << ht.Find(43) << endl;
		ht.Erase(43);
		ht.Print();
		cout << ht.Find(43) << endl;
	}
	void test02()
	{
		string arr[] = { "香蕉","苹果","橘子","香蕉","苹果" ,"香蕉","苹果" ,"香蕉" };
		HashTable<string, int> ht;
		for (auto e : arr)
		{
			HashNode<string, int>* ret = ht.Find(e);
			if (ret)
				ret->_kv.second++;
			else
				ht.Insert(make_pair(e, 1));
		}
	}
	void test03()
	{
		const size_t N = 1000000;

		unordered_set<int> us;
		set<int> s;
		HashTable<int, int> ht;

		vector<int> v;
		v.reserve(N);
		srand(time(0));
		for (size_t i = 0; i < N; ++i)
		{
			//v.push_back(rand()); // N比较大时，重复值比较多
			v.push_back(rand() + i); // 重复值相对少
			//v.push_back(i); // 没有重复，有序
		}

		size_t begin1 = clock();
		for (auto e : v)
		{
			s.insert(e);
		}
		size_t end1 = clock();
		cout << "set insert:" << end1 - begin1 << endl;

		size_t begin2 = clock();
		for (auto e : v)
		{
			us.insert(e);
		}
		size_t end2 = clock();
		cout << "unordered_set insert:" << end2 - begin2 << endl;

		size_t begin10 = clock();
		for (auto e : v)
		{
			ht.Insert(make_pair(e, e));
		}
		size_t end10 = clock();
		cout << "HashTbale insert:" << end10 - begin10 << endl << endl;


		size_t begin3 = clock();
		for (auto e : v)
		{
			s.find(e);
		}
		size_t end3 = clock();
		cout << "set find:" << end3 - begin3 << endl;

		size_t begin4 = clock();
		for (auto e : v)
		{
			us.find(e);
		}
		size_t end4 = clock();
		cout << "unordered_set find:" << end4 - begin4 << endl;

		size_t begin11 = clock();
		for (auto e : v)
		{
			ht.Find(e);
		}
		size_t end11 = clock();
		cout << "HashTable find:" << end11 - begin11 << endl << endl;

		cout << "插入数据个数：" << us.size() << endl << endl;
		ht.Some();

		size_t begin5 = clock();
		for (auto e : v)
		{
			s.erase(e);
		}
		size_t end5 = clock();
		cout << "set erase:" << end5 - begin5 << endl;

		size_t begin6 = clock();
		for (auto e : v)
		{
			us.erase(e);
		}
		size_t end6 = clock();
		cout << "unordered_set erase:" << end6 - begin6 << endl;

		size_t begin12 = clock();
		for (auto e : v)
		{
			ht.Erase(e);
		}
		size_t end12 = clock();
		cout << "HashTable Erase:" << end12 - begin12 << endl << endl;
	}
}

test.cpp

#include<iostream>
#include<string>
#include<set>
#include<unordered_set>
using namespace std;
#include"HashTable.h"
#include"test.h"

int main()
{
	kky_hash_bucket::test03();
}

感谢大家观看！！！