devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++：哈希表和unordered系列容器的封装_cpp 哈希表容器

作者：酷酷是懒虫 | 2024-07-26 16:22:24

赞

踩

cpp 哈希表容器

一、unordered系列关联式容器的介绍

         在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到log2N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是
其底层结构不同（哈希表）

1.1 unordered_map

unordered_map的介绍

1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
3. 在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
6. 它的迭代器至少是前向迭代器。

7.unordered就是无序的意思

使用细节基本上和map一致


1.2 unordered_set

unordered_set的文档说明

1.3 性能对比

通过一个测试代码来比较unordered_set 和set的效率

  1. void testop() //测试  底层是红黑树和哈希表的效率比对    
  2. {
  3. 	const size_t N = 1000000;
  4.  
  5. 	unordered_set<int> us;
  6. 	set<int> s;
  7.  
  8. 	vector<int> v;
  9. 	v.reserve(N);
  10. 	srand((unsigned int)time(0));
  11. 	for (size_t i = 0; i < N; ++i)
  12. 	{
  13. 		v.push_back(rand());
  14. 		//v.push_back(rand()+i);
  15. 		//v.push_back(i);
  16. 	}
  17.  
  18. 	size_t begin1 = clock();
  19. 	for (auto e : v)
  20. 	{
  21. 		s.insert(e);
  22. 	}
  23. 	size_t end1 = clock();
  24. 	cout << "set insert:" << end1 - begin1 << endl;
  25.  
  26. 	size_t begin2 = clock();
  27. 	for (auto e : v)
  28. 	{
  29. 		us.insert(e);
  30. 	}
  31. 	size_t end2 = clock();
  32. 	cout << "unordered_set insert:" << end2 - begin2 << endl;
  33.  
  34.  
  35. 	size_t begin3 = clock();
  36. 	for (auto e : v)
  37. 	{
  38. 		s.find(e);
  39. 	}
  40. 	size_t end3 = clock();
  41. 	cout << "set find:" << end3 - begin3 << endl;
  42.  
  43. 	size_t begin4 = clock();
  44. 	for (auto e : v)
  45. 	{
  46. 		us.find(e);
  47. 	}
  48. 	size_t end4 = clock();
  49. 	cout << "unordered_set find:" << end4 - begin4 << endl << endl;
  50.  
  51. 	cout << s.size() << endl;
  52. 	cout << us.size() << endl << endl;;
  53.  
  54. 	size_t begin5 = clock();
  55. 	for (auto e : v)
  56. 	{
  57. 		s.erase(e);
  58. 	}
  59. 	size_t end5 = clock();
  60. 	cout << "set erase:" << end5 - begin5 << endl;
  61.  
  62. 	size_t begin6 = clock();
  63. 	for (auto e : v)
  64. 	{
  65. 		us.erase(e);
  66. 	}
  67. 	size_t end6 = clock();
  68. 	cout << "unordered_set erase:" << end6 - begin6 << endl << endl;
  69. }

 我们发现，整体而言都是unordered系列更优一点，尤其是find的效率最为突出

二、哈希表

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

2.1 哈希表的概念

        顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即
O(log2 N)，搜索的效率取决于搜索过程中元素的比较次数
 

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc->哈希函数)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素->哈希表

（1）插入元素
       根据待插入元素的关键码，以此哈希函数计算出该元素的存储位置并按此位置进行存放
（2）搜索元素
       对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置
取元素比较，若关键码相等，则搜索成功
（3）删除元素

       对元素的关键码进行同样的计算，找到对应的位置并删除

        该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表
 

2.2 哈希冲突

         不同关键字通过相同哈希哈数计算出相同的哈希地址（不同的值映射到了同一个位置），该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。


下面我们就会重点介绍什么情况下会出现哈希冲突以及如何解决哈希冲突！！

2.3 哈希函数

哈希函数：将任意长度的数据映射到固定长度输出的算法（将键值映射为存储位置）

哈希函数设计原则：
（1）哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
（2）哈希函数计算出来的地址能均匀分布在整个空间中
（3）哈希函数应该比较简单

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
 

常见的哈希函数：

（1）直接定址法--(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况


我们的位图其实就是用的直接定址法，可以理解为每个键值都有一个单独的映射位置。

（2） 除留余数法（常用）

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
 

哈希表的实现就是用的这个方法！！

（3）平方取中法--(不常用)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
 

（4）折叠法--（不常用）

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合：事先不需要知道关键字的分布，适合关键字位数比较多的情况
 

（5）随机数法--（不常用）

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
通常应用于关键字长度不等时采用此法
 

（6）数学分析法（不常用）

       设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定
相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

       假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同
的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。
          数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的
若干位分布较均匀的情况
 

哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

接下来我们将会重点讲解哈希表的实现，其底层用的是除留余数法，  解决其哈希冲突的方法有两种，即开放定址法和拉链法。
 

2.4 开放定址法实现简单哈希表

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。
     

那么我们如何寻找下一个位置呢？答案就是线性探测。

         比如图中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
        但是线性探测会存在以下两个问题：

（1）不确定每个位置的初始值放多少，不能是放0，否则该位置如果本来就要放0的话，这个时候我们就没办法区分了！！

（2）插入的时候线性探测是向后查找直到空停止并放入，所以删除的时候也应该是线性探测向后查找直到空的这段区域必然可以找到这个要删除的元素，但是如上图44的位置依赖于前面4567的定位，假如4-7中的任意一个元素删除了，那么下一次要删44的时候就会找不到44.

    为了解决上面的两个问题，我们的策略就是设置3种状态，EMPTY 表示空， EXIST表示有，DELETE表示已删除。 我们给每个位置都存一个状态。

    同时为了防止元素扎堆的情况，可以采用二次线性探测，这样可以减少冲突。

2.4.1 基本结构

  1. enum State //设置状态本质上是为了解决两个问题 1，一开始的元素不知道是多少比较合适  如果是0的话  可能加入的数也正好是0  2.如果该位置元素删除了，那么会导致因为该元素占位而到别的位置的元素找不到！！！
  2. {
  3. 	EMPTY,//空
  4. 	EXIST,//存在
  5. 	DELETE //删除  
  6. };
  7.  
  8. template<class K, class V>
  9. struct HashData
  10. {
  11. 	pair<K, V> _kv;//会调用自己的默认构造
  12. 	State _state = EMPTY;
  13. };
  14.  
  15.  
  16. template<class K, class V>
  17. class HashTable
  18. {
  19. public:
  20. 	
  21. private:
  22. 	vector<HashData<K, V>> _tables;
  23. 	size_t _n = 0; //记录有效的数据个数
  24. };

2.4.2 插入

  1. bool Insert(const pair<K, V>& kv)
  2. {
  3. 	if (Find(kv.first))  return false;//键值不冗余， 所以如果存在，就没有必要去插入
  4.  
  5. 	//考虑扩容的问题   负载因子为0.7
  6. 	if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
  7. 	{
  8. 	   //利用现代写法 让你去搞  然后窃取革命成果
  9. 		size_t newsize = _tables.size() == 0 ? 10 :_tables.size()*2;
  10. 		HashTable<K, V> newt;
  11. 		newt._tables.resize(newsize);
  12. 	    //遍历旧表 然后重新搞到新表上
  13. 		for (auto& data : _tables)
  14. 			if (data._state == EXIST)
  15. 				newt.Insert(data._kv);
  16. 		_tables.swap(newt._tables);//窃取革命成果
  17. 	}
  18.  
  19.  
  20. 	size_t hashi = kv.first % _tables.size();//%容量是没有用的，%size才是有用的  因为光扩容，也是不敢随机访问的！
  21. 	//进行线性探测 当前如果存在就要往后推
  22. 	size_t i = 1;
  23. 	size_t index = hashi;
  24. 	while (_tables[index]._state == EXIST) //
  25. 	{
  26. 		index = hashi + i; //这样子方便后面修改成二次检测
  27. 		//index可能会越界，可能需要去修正一下
  28. 		index %= _tables.size();
  29. 		++i;
  30. 	}
  31. 	//在相应的位置进行操作
  32. 	_tables[index]._kv = kv;
  33. 	_tables[index]._state = EXIST;
  34. 	++_n; //更新次数
  35.  
  36. 	return true;
  37. }

  (1) 哈希表在%的时候一定要%size而不是%capacity（可能会存在越界，比如说size只有10，而capacity是20，如果映射到15也是不可以访问的！！），因为我们空间一定是开好了的而不是中间插入进去。 扩容的时候也是一定要用resize而不是reserve。

（2）哈希表在某些时候需要去扩容，我们设置一个负载因子（假设0.7）,超出这个范围我们就是扩容，但是我们不能单纯地去resize，因为映射关系会完全改变。比如说原本10的空间，12是插入在2的位置，但是空间变成20后，12就应该插入到12的位置上。所以我们要创建一个新表，然后遍历旧表拿数据，重新计算映射位置。      每次又要走一次线性探测，为了防止代码冗余，此时有两种方案，一种是将线性探测的代码封装起来，然后复用   另一种方案是现代写法，再创建一个新的对象，然后让该对象去调用insert，最后再利用swap窃取成果。

2.4.3 查找

  1. HashData<K, V>* Find(const K& key) //返回值为指针是方便我们在找不到的时候可以返回空
  2. {
  3. 	if (_tables.size() == 0) return nullptr;
  4. 	//一样要进行线性探测
  5. 	size_t hashi = key % _tables.size();
  6. 	size_t i = 1;
  7. 	size_t index = hashi;
  8. 	while (_tables[index]._state != EMPTY)  //不等于空的时候往后走
  9. 	{
  10. 		if (_tables[index]._state == EXIST && _tables[index]._kv.first == key)  //前面的判断是确保当前位置不为DETELE 状态  因为为我们封装的删除是一个伪删除，并不是真的删除
  11. 			return &_tables[index];
  12. 		//如果找不到，往后继续走
  13. 		index = hashi + i;
  14. 		index %= _tables.size();
  15. 		++i;
  16.  
  17. 		//极端情况    插入一部分 +删除一部分 +插入一部分 正好所有的位置都是存在+删除 此时上面面临着死循环  所以我们堆i进行判断，如果index==hashi说明已经找了一圈了，此时就跳出去
  18. 		if (index == hashi) break;
  19. 	}
  20. 	return nullptr;
  21. }

        不等于空就可以继续向后线性探测，因为我们设置delete状态就是想实现伪删除，这样在删除某些元素的时候不会影响线性探测。

极端情况：如果正好插入一部分，删除一部分，再插入一部分，导致所有的位置都是存在+删除，那么循环永远不会停止，这个时候我们就要去判断如果正好走了一圈了，就可以break了。

2.4.4 删除

  1. bool Erase(const K& key)
  2. {
  3. 	HashData<K, V>* ret = Find(key); //复用find
  4. 	if (ret) //如果找到了  将该位置改成删除
  5. 	{
  6. 		ret->_state = DELETE; //伪删除
  7. 		--_n;
  8. 		return true;
  9. 	}
  10. 	return false;
  11. }

复用Find即可，然后进行伪删除。 

2.4.5 整体代码的实现

  1. 	enum State //设置状态本质上是为了解决两个问题 1，一开始的元素不知道是多少比较合适  如果是0的话  可能加入的数也正好是0  2.如果该位置元素删除了，那么会导致因为该元素占位而到别的位置的元素找不到！！！
  2. 	{
  3. 		EMPTY,//空
  4. 		EXIST,//存在
  5. 		DELETE //删除  
  6. 	};
  7.  
  8. 	template<class K, class V>
  9. 	struct HashData
  10. 	{
  11. 		pair<K, V> _kv;//会调用自己的默认构造
  12. 		State _state = EMPTY;
  13. 	};
  14.  
  15.  
  16. 	template<class K, class V>
  17. 	class HashTable
  18. 	{
  19. 	public:
  20. 		bool Insert(const pair<K, V>& kv)
  21. 		{
  22. 			if (Find(kv.first))  return false;//键值不冗余， 所以如果存在，就没有必要去插入
  23.  
  24. 			//考虑扩容的问题   负载因子为0.7
  25. 			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
  26. 			{
  27. 			   //利用现代写法 让你去搞  然后窃取革命成果
  28. 				size_t newsize = _tables.size() == 0 ? 10 :_tables.size()*2;
  29. 				HashTable<K, V> newt;
  30. 				newt._tables.resize(newsize);
  31. 			    //遍历旧表 然后重新搞到新表上
  32. 				for (auto& data : _tables)
  33. 					if (data._state == EXIST)
  34. 						newt.Insert(data._kv);
  35. 				_tables.swap(newt._tables);//窃取革命成果
  36. 			}
  37.  
  38.  
  39. 			size_t hashi = kv.first % _tables.size();//%容量是没有用的，%size才是有用的  因为光扩容，也是不敢随机访问的！
  40. 			//进行线性探测 当前如果存在就要往后推
  41. 			size_t i = 1;
  42. 			size_t index = hashi;
  43. 			while (_tables[index]._state == EXIST) //
  44. 			{
  45. 				index = hashi + i; //这样子方便后面修改成二次检测
  46. 				//index可能会越界，可能需要去修正一下
  47. 				index %= _tables.size();
  48. 				++i;
  49. 			}
  50. 			//在相应的位置进行操作
  51. 			_tables[index]._kv = kv;
  52. 			_tables[index]._state = EXIST;
  53. 			++_n; //更新次数
  54.  
  55. 			return true;
  56. 		}
  57.  
  58. 		HashData<K, V>* Find(const K& key) //返回值为指针是方便我们在找不到的时候可以返回空
  59. 		{
  60. 			if (_tables.size() == 0) return nullptr;
  61. 			//一样要进行线性探测
  62. 			size_t hashi = key % _tables.size();
  63. 			size_t i = 1;
  64. 			size_t index = hashi;
  65. 			while (_tables[index]._state != EMPTY)  //不等于空的时候往后走
  66. 			{
  67. 				if (_tables[index]._state == EXIST && _tables[index]._kv.first == key)  //前面的判断是确保当前位置不为DETELE 状态  因为为我们封装的删除是一个伪删除，并不是真的删除
  68. 					return &_tables[index];
  69. 				//如果找不到，往后继续走
  70. 				index = hashi + i;
  71. 				index %= _tables.size();
  72. 				++i;
  73.  
  74. 				//极端情况    插入一部分 +删除一部分 +插入一部分 正好所有的位置都是存在+删除 此时上面面临着死循环  所以我们堆i进行判断，如果index==hashi说明已经找了一圈了，此时就跳出去
  75. 				if (index == hashi) break;
  76. 			}
  77. 			return nullptr;
  78. 		}
  79.  
  80. 		bool Erase(const K& key)
  81. 		{
  82. 			HashData<K, V>* ret = Find(key); //复用find
  83. 			if (ret) //如果找到了  将该位置改成删除
  84. 			{
  85. 				ret->_state = DELETE; //伪删除
  86. 				--_n;
  87. 				return true;
  88. 			}
  89. 			return false;
  90. 		}
  91.  
  92.  
  93. 	private:
  94. 		vector<HashData<K, V>> _tables;
  95. 		size_t _n = 0; //记录有效的数据个数
  96. 	};

2.5 拉链法实现简单哈希表

        开放定址法是一个比较粗暴的方式，因为其是一种恶性循环，冲突之后就占别的位置，而后面一旦出现本该放在该位置的元素，也得另外占别的位置。 

       而拉链法相对来说更文明一点，如果发生冲突了，我就跟你挤一挤。接在一起。

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

开散列中每个桶中放的都是发生哈希冲突的元素。

  1. //因为有扩容(负载因子控制)的存在!!!!，哈希桶增删查改的时间复杂度都是O（1）      虽然插入可能会存在扩容，扩容操作是O（N） 但是整体而言扩容只在那一瞬间 因为我们的哈希表是不断在插入元素的 
  2.                                                    //相当于是一个好学生考试，他大多数情况下都考得好就偶尔一两次考不好  同理，这边插入的时间复杂度大多数情况是O(1) O(N)只在一瞬间
  3. //跟快排一样，快排也非常难出现最坏情况 因为有了随机取KEY（针对有序） 以及这个三路划分（针对重复）
  4. namespace HashBucket //哈希桶  拉链法  开散列
  5. {
  6.  
  7. 	template<class K,class V>
  8. 	struct HashNode
  9. 	{
  10. 		HashNode<K, V>* _next;
  11. 		pair<K, V> _kv;
  12.         
  13. 		HashNode(const pair<K, V>& kv)
  14. 			:_next(nullptr)
  15. 			, _kv(kv)
  16. 		{}
  17. 	};
  18.  
  19.  
  20. 	template<class K>
  21. 	struct HashFunc //默认 int
  22. 	{
  23. 		size_t operator()(const K& key)
  24. 		{
  25. 			return key;
  26. 		}
  27. 	};
  28.  
  29. 	template<>  //因为string 用的比较多， 所以我们可以专门搞一个模板特化版本  专门针对string  有特化走特化，没特化走普通类型
  30. 	struct HashFunc<string>
  31. 	{
  32. 		// 尽量要控制不要重复  1.将字符串的所有ASCII码加起来 2，但是加起来之后，对于字符相同但是顺序不同的字符串 还是不太好区分，所以这里要用以恶搞BKDR哈希算法
  33. 		size_t operator()(const string& s)
  34. 		{
  35. 			size_t hash = 0;
  36. 			for (auto ch : s)  //将字符串转化成整型，通过映射整型去找到字符串对应的位置
  37. 			{
  38. 				hash += ch;  //但是光有这一句代码的话， 应对一些字符相同但是顺序相同的字符串的时候，仍然是不好区分的 
  39. 				hash *= 31;  //BKDR哈希 
  40. 			}
  41.  
  42. 			return hash;
  43. 		}
  44. 	};
  45.  
  46.  
  47. 	template<class K,class V,class Hash= HashFunc<K>>
  48. 	class HashTable
  49. 	{
  50. 		typedef HashNode<K, V> Node;
  51. 	public:
  52. 		~HashTable()
  53. 		{
  54. 			clear();
  55. 		}
  56.  
  57. 		bool Insert(const pair<K, V>& kv)
  58. 		{
  59. 			if (Find(kv.first)) return false;//如果有就不用找了  
  60. 			Hash hash;//通过仿函数控制可以K变成可以取模
  61. 			//负载因子为1时进行扩容
  62. 			if (_n == _tables.size()) //这里不适合用现代写法，因为如果去调用insert的话，会重新申请很多新的结点，然后又要释放很多结点 效率太低了    //解决方案就是  原表的结点重新计算，挪动到新表的位置                                                                  
  63. 			{
  64. 				//size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2; 原来的版本
  65.  
  66. 				size_t newsize = GetNextPrime(_tables.size()); //按照SGI版本的素数表
  67. 				第一种方案  创建一个新的表来完成这个任务
  68. 				//HashTable<K, V> newht;
  69. 				//newht._tables.resize(newsize);
  70. 				//for (auto&cur : _tables)
  71. 				//{
  72. 				//	while (cur)
  73. 				//	{
  74. 				//		newht.Insert(cur->_kv);
  75. 				//		cur = cur->_next;
  76. 				//	}
  77. 				//}
  78. 				//_tables.swap(newht._tables); 
  79.  
  80. 				vector<Node*> newtables(newsize, nullptr);
  81. 				//将结点一个个解下来放到新表中 （复用的话会创建很多新的结点 其实没有什么必要 ）
  82. 				for (Node*& cur : _tables)
  83. 					while (cur)
  84. 					{
  85. 						Node* next = cur->_next;
  86. 						size_t hashi = hash(cur->_kv.first) % newtables.size(); //重新计算   
  87. 						//头插到新表
  88. 						cur->_next = newtables[hashi];
  89. 						newtables[hashi] = cur;
  90. 						cur = next;
  91. 					}
  92. 				_tables.swap(newtables);//交换过来 
  93. 			}
  94. 			size_t hashi = hash(kv.first) % _tables.size();  //只有整形是支持取模的，其他的类型是不一定的
  95. 			//执行头插的逻辑
  96. 			Node* newnode = new Node(kv);
  97. 			newnode->_next = _tables[hashi];
  98. 			_tables[hashi] = newnode;//成为新的头
  99. 			++_n;
  100. 			return true;
  101. 		}
  102.  
  103. 			Node* Find(const K&key)
  104. 			{
  105. 				if (_tables.size() == 0)  return nullptr;
  106. 				Hash hash;
  107. 				size_t hashi = hash(key) % _tables.size(); //找到这个点
  108. 				Node* cur = _tables[hashi];
  109. 				while (cur)
  110. 				{
  111. 					if (cur->_kv.first == key) return cur;
  112. 					cur = cur->_next;
  113. 				}
  114. 				return nullptr;
  115. 			}
  116.  
  117. 			bool Erase(const K& key)
  118. 			{
  119. 				Hash hash;
  120. 				//这边就不能直接复用find了，因为只是拿到该结点，但是还得从里面删掉才有用
  121. 				size_t hashi = hash(key) % _tables.size();//找到这个位置
  122. 				Node* prev = nullptr;
  123. 				Node* cur = _tables[hashi];
  124. 				while (cur)
  125. 				{
  126. 					if (cur->_kv.first == key) //执行删除
  127. 					{
  128. 						if (prev == nullptr)   _tables[hashi] = cur->_next;         //说明第一个就要删
  129. 						else  prev->_next = cur->_next;
  130. 							delete cur;
  131. 							--_n;
  132. 							return true;
  133. 					}
  134. 					prev = cur;
  135. 					cur = cur->_next;
  136. 				}
  137. 				return false; //说明找不到
  138. 			}
  139.  
  140.  
  141. 			size_t MaxBucketSize() //统计桶的最大长度并返回  检测查找的效率
  142. 			{
  143. 				size_t max = 0;
  144. 				for (size_t i = 0; i < _tables.size(); ++i)
  145. 				{
  146. 					auto cur = _tables[i];
  147. 					size_t size = 0;
  148. 					while (cur)
  149. 					{
  150. 						++size;
  151. 						cur = cur->_next;
  152. 					}
  153. 					printf("[%zd]->%zd\n", i, size); //打印所有桶的长度 让我们看到具体的分布情况  这样就可以测出查找的时间复杂度
  154. 					if (size > max) 	max = size;
  155. 				}
  156. 				return max;
  157. 			}
  158.  
  159. 			void clear()
  160. 			{
  161. 				for (Node*& cur : _tables)
  162. 				{
  163. 					while (cur)
  164. 					{
  165. 						Node* next = cur->_next;
  166. 						delete cur;
  167. 						cur = next;
  168. 					}
  169.  
  170. 					cur = nullptr;
  171. 				}
  172. 			}
  173.  
  174.  
  175. 			//SGI版本    主要是数学上提到说如果表的长度是素数的话，模的时候更不容易冲突  
  176. 			//但是如果我们正常的扩2倍肯定是难以维持他是素数的，所以就有了这样一个解决方案，专门给了一个素数表 让哈希表的长度按照这个表去更新 这样可以保证长度一直是素数
  177. 			//SGI版本是这么实现的
  178. 			size_t GetNextPrime(size_t prime)
  179. 			{
  180. 				// SGI
  181. 				static const int __stl_num_primes = 28;
  182. 				static const unsigned long __stl_prime_list[__stl_num_primes] =
  183. 				{
  184. 					53, 97, 193, 389, 769,
  185. 					1543, 3079, 6151, 12289, 24593,
  186. 					49157, 98317, 196613, 393241, 786433,
  187. 					1572869, 3145739, 6291469, 12582917, 25165843,
  188. 					50331653, 100663319, 201326611, 402653189, 805306457,
  189. 					1610612741, 3221225473, 4294967291
  190. 				}; //实际上是不可能扩到最大的 因为 2^32次方  哪怕是char类型都有4G了  指针都有16G了
  191. 				    /*1Byte（字节）=8bit（位）
  192. 				    1 KB = 1024 Byte
  193. 					1 MB = 1024 KB
  194. 					1 GB = 1024 MB
  195. 					1TB = 1024GB*/
  196. 			
  197.  
  198. 				size_t i = 0;
  199. 				for (; i < __stl_num_primes; ++i)
  200. 				{
  201. 					if (__stl_prime_list[i] > prime)
  202. 						return __stl_prime_list[i];
  203. 				}
  204.  
  205. 				return __stl_prime_list[i];  //在表里依次遍历 找到比原先大的那个素数值
  206. 			}
  207.  
  208. 	private:
  209. 		vector<Node*> _tables; //指针数组
  210. 		size_t _n=0;//记录有效元素的个数 
  211. 	};

三、unordered系列容器的封装

3.1 改造拉链法哈希表

  1. //自己实现的时候  一定要一步一步来， 先封装哈希表 然后再封装简单的map和set  然后再封装迭代器让插入跑起来，然后再去考虑其他的一些细节问题， 不要一下子把所有的模板参数都加上 
  2. //要一步一步来
  3.  
  4. template<class T>
  5. struct HashNode
  6. {
  7. 	HashNode<T>* _next;
  8. 	T _data; //T决定存的是KV 还是K
  9.  
  10. 	HashNode(const T& data)
  11. 		:_next(nullptr)
  12. 		,_data(data)
  13. 	{}
  14. };
  15. template<class K>
  16. struct HashFunc //默认 int
  17. {
  18. 	size_t operator()(const K& key)
  19. 	{
  20. 		return key;
  21. 	}
  22. };
  23.  
  24. template<>  //因为string 用的比较多， 所以我们可以专门搞一个模板特化版本  专门针对string  有特化走特化，没特化走普通类型  默认支持
  25. struct HashFunc<string>
  26. {
  27. 	// 尽量要控制不要重复  1.将字符串的所有ASCII码加起来 2，但是加起来之后，对于字符相同但是顺序不同的字符串 还是不太好区分，所以这里要用以恶搞BKDR哈希算法
  28. 	size_t operator()(const string& s)
  29. 	{
  30. 		size_t hash = 0;
  31. 		for (auto ch : s)  //将字符串转化成整型，通过映射整型去找到字符串对应的位置
  32. 		{
  33. 			hash += ch;  //但是光有这一句代码的话， 应对一些字符相同但是顺序相同的字符串的时候，仍然是不好区分的 
  34. 			hash *= 31;  //BKDR哈希 
  35. 		}
  36.  
  37. 		return hash;
  38. 	}
  39. };
  40.  
  41. template<class K, class T, class KeyOfT, class Hash> //  前置声明 不要给缺省参数 
  42. class HashTable;
  43.  
  44.  
  45. template<class K, class T, class Ref, class Ptr, class KeyOfT,class Hash>//缺省不能在这传  在这传会写死
  46. struct _HashIterator //迭代器的封装
  47. {
  48. 	typedef HashNode<T> Node;//结点
  49. 	typedef HashTable<K, T, KeyOfT,Hash> HT;//处理指向哈希桶的指针
  50. 	typedef _HashIterator<K, T, Ref, Ptr, KeyOfT,Hash> Self;//自己
  51. 	typedef _HashIterator<K, T, T&, T*, KeyOfT, Hash> Iterator; //服务set普通迭代器 
  52. 	//在红黑树中也是按照这个逻辑，key被修改会破坏红黑树的整体结构， 所以我们必须要去控制
  53.     
  54. 	//成员变量 必然要有结点指针以及哈希桶的指针
  55. 	Node* _node;
  56. 	const HT* _ht;
  57.  
  58.  
  59. 	_HashIterator(Node* node,const HT* ht) //这样可以保证const可以接收 普通的也可以接收 因为权限可以缩小
  60. 		:_node(node)
  61. 		, _ht(ht)
  62. 	{}
  63.  
  64. 	_HashIterator(const Iterator& it) //拷贝构造  本质上是为了set去服务的
  65. 		:_node(it._node)   //普通迭代器可以转化成const迭代器 
  66. 		, _ht(it._ht)
  67. 	{}
  68.  
  69. 	Ref operator*()
  70. 	{
  71. 		return _node->_data;
  72. 	}
  73.  
  74. 	Ptr operator->()
  75. 	{
  76. 		return &operator*();
  77. 	}
  78.  
  79. 	bool operator!=(const Self& s)
  80. 	{
  81. 		return _node != s._node;
  82. 	}
  83.  
  84. 	Self& operator++()
  85. 	{
  86. 		if (_node->_next) _node = _node->_next;// 如果结点下一个不为空，就去找下一个
  87. 		else //如果结点的下一个为空，那么就去哈希桶找下一个桶
  88. 		{
  89. 			KeyOfT kot;//控制data取出来的是什么
  90. 			//先算一下自己在当前桶的位置 
  91. 			size_t hashi = _ht->bucket(kot(_node->_data)); //无法访问私有成员 要么用友元 要么封装gettable和getbucketsize这两个函数 
  92. 			++hashi;
  93. 			while (hashi < _ht->_buckets.size())
  94. 			{
  95. 				if (_ht->_buckets[hashi]) //如果找到了
  96. 				{
  97. 					_node = _ht->_buckets[hashi];
  98. 					break;
  99. 				}
  100. 				++hashi; //继续找下一个桶
  101. 			}
  102.            //此时可能有两种情况  一种是成功找到，一种是走到最后都没找到
  103. 			if (hashi == _ht->_buckets.size()) _node = nullptr;
  104. 		}
  105. 		return *this;
  106. 	}
  107.  
  108. 	Self operator++(int)
  109. 	{
  110. 		Self temp = *this;
  111. 		++*this;
  112. 		return temp;
  113. 	}
  114.  
  115. };
  116.  
  117. //    class Pred = equal_to<Key>
  118.  
  119. template<class K, class T, class KeyOfT,class Hash>
  120. class HashTable
  121. {
  122. 	     typedef HashNode<T> Node;
  123. 		 //友元  为了能够让迭代器访问私有成员table  但是这样会破坏封装性 不推荐使用  还有一种方法是封装一个getbucketsize函数和gettables的函数  
  124. 	     template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
  125. 		 friend	struct _HashIterator; 
  126. public:
  127. 	~HashTable()
  128. 	{
  129. 		clear();
  130. 	}
  131.  
  132. 	typedef _HashIterator<K, T,T&,T*,KeyOfT, Hash>  iterator;
  133. 	typedef _HashIterator<K, T, const T&, const T*, KeyOfT, Hash> const_iterator;
  134. 	typedef HashTable<K, T, KeyOfT, Hash>   Self;
  135. 	iterator begin()  //得找到第一个有效的桶
  136. 	{
  137. 		Node* cur = nullptr; //防止全部为空的时候
  138. 		for (size_t i = 0; i < _buckets.size(); ++i)
  139. 		{
  140. 			if (_buckets[i])
  141. 			{
  142. 				cur = _buckets[i];
  143. 				break;
  144. 			}
  145. 		}
  146. 		return iterator(cur, this);  //this指针
  147. 	}
  148.  
  149. 	iterator end()  
  150. 	{
  151. 		return iterator(nullptr, this);  //this指针
  152. 	}
  153.  
  154.  
  155. 	const_iterator begin() const
  156. 	{
  157. 		Node* cur = nullptr;
  158. 		for (size_t i = 0; i < _buckets.size(); ++i)
  159. 		{
  160. 			cur = _buckets[i];
  161. 			if (_buckets[i])
  162. 			{
  163. 				cur = _buckets[i];
  164. 				break;
  165. 			}
  166. 		}
  167. 		return const_iterator(cur, this);
  168. 	}
  169.  
  170.  
  171. 	
  172. 	const_iterator end() const
  173. 	{
  174. 		return const_iterator(nullptr, this);
  175. 	}
  176.  
  177.  
  178. 	pair<iterator, bool> Insert(const T& data)
  179. 	{
  180. 		KeyOfT kot;//控制data取出来的是什么
  181. 		iterator it = Find(kot(data));
  182. 		if (it != end()) return make_pair(it, false);//如果有就不用找了  
  183. 		
  184. 		//负载因子为1时进行扩容
  185. 		if (_n == _buckets.size()) //这里不适合用现代写法，因为如果去调用insert的话，会重新申请很多新的结点，然后又要释放很多结点 效率太低了    //解决方案就是  原表的结点重新计算，挪动到新表的位置                                                                  
  186. 		{
  187. 			//size_t newsize = _buckets.size() == 0 ? 10 : _buckets.size() * 2; 原来的版本
  188.  
  189. 			size_t newsize = GetNextPrime(_buckets.size()); //按照SGI版本的素数表
  190. 			第一种方案  创建一个新的表来完成这个任务
  191. 			//HashTable<K, V> newht;
  192. 			//newht._buckets.resize(newsize);
  193. 			//for (auto&cur : _buckets)
  194. 			//{
  195. 			//	while (cur)
  196. 			//	{
  197. 			//		newht.Insert(cur->_kv);
  198. 			//		cur = cur->_next;
  199. 			//	}
  200. 			//}
  201. 			//_buckets.swap(newht._buckets); 
  202.  
  203. 			vector<Node*> newtables(newsize, nullptr);
  204. 			//将结点一个个解下来放到新表中 （复用的话会创建很多新的结点 其实没有什么必要 ） 所以这里不用第一种方法  
  205. 			for (Node*& cur : _buckets)
  206. 				while (cur)
  207. 				{
  208. 					Node* next = cur->_next;
  209. 					size_t hashi = bucket(kot(cur->_data)); //重新计算   
  210. 					//头插到新表
  211. 					cur->_next = newtables[hashi];
  212. 					newtables[hashi] = cur;
  213. 					cur = next;
  214. 				}
  215. 			_buckets.swap(newtables);//交换过来 
  216. 		}
  217. 		size_t hashi = bucket(kot(data));  //只有整形是支持取模的，其他的类型是不一定的
  218. 		//执行头插的逻辑
  219. 		Node* newnode = new Node(data);
  220. 		newnode->_next = _buckets[hashi];
  221. 		_buckets[hashi] = newnode;//成为新的头
  222. 		++_n;
  223. 		return make_pair(iterator(newnode,this),true);
  224. 	}
  225.  
  226. 	iterator Find(const K& key)
  227. 	{
  228. 		if (empty())  return end(); //为空 就没啥好找的了
  229. 		KeyOfT kot;//控制data取出来的是什么
  230. 		size_t hashi = bucket(key); //找到这个点
  231. 		Node* cur = _buckets[hashi];
  232. 		while (cur)
  233. 		{
  234. 			if (kot(cur->_data) == key) return iterator(cur, this);
  235. 			cur = cur->_next;
  236. 		}
  237. 		return iterator(nullptr, this);
  238. 	}
  239.  
  240. 	bool Erase(const K& key)
  241. 	{
  242. 		Hash hash;//控制模出来的情况 因为可能会是字符串什么的
  243. 		KeyOfT kot;//控制data取出来的是什么
  244. 		//这边就不能直接复用find了，因为只是拿到该结点，但是还得从里面删掉才有用
  245. 		size_t hashi = bucket(key);//找到key对应的桶
  246. 		Node* prev = nullptr;
  247. 		Node* cur = _buckets[hashi];
  248. 		while (cur)
  249. 		{
  250. 			if (kot(cur->_data) == key) //执行删除
  251. 			{
  252. 				if (prev == nullptr)   _buckets[hashi] = cur->_next;         //说明第一个就要删
  253. 				else  prev->_next = cur->_next;
  254. 				delete cur;
  255. 				--_n;
  256. 				return true;
  257. 			}
  258. 			prev = cur;
  259. 			cur = cur->_next;
  260. 		}
  261. 		return false; //说明找不到
  262. 	}
  263.  
  264. 	void clear() //清空桶中的元素
  265. 	{
  266. 		for (Node*& cur : _buckets)
  267. 		{
  268. 			while (cur)
  269. 			{
  270. 				Node* next = cur->_next;
  271. 				delete cur;
  272. 				cur = next;
  273. 			}
  274. 			cur = nullptr;
  275. 		}
  276. 	}
  277. 	
  278.  
  279. 	size_t size() const //哈希表中的元素个数
  280. 	{
  281. 		return _n;
  282. 	}
  283.  
  284. 	bool empty() const
  285. 	{
  286. 		return size() == 0;
  287. 	}
  288.  
  289. 	void swap(Self& s)
  290. 	{
  291. 		_buckets.swap(s._buckets);
  292. 		std::swap(_n, s._n);
  293. 	}
  294.  
  295.  
  296. 	//SGI版本    主要是数学上提到说如果表的长度是素数的话，模的时候更不容易冲突  
  297. 	//但是如果我们正常的扩2倍肯定是难以维持他是素数的，所以就有了这样一个解决方案，专门给了一个素数表 让哈希表的长度按照这个表去更新 这样可以保证长度一直是素数
  298. 	//SGI版本是这么实现的
  299. 	size_t GetNextPrime(size_t prime)
  300. 	{
  301. 		// SGI
  302. 		static const int __stl_num_primes = 28;
  303. 		static const unsigned long __stl_prime_list[__stl_num_primes] =
  304. 		{
  305. 			53, 97, 193, 389, 769,
  306. 			1543, 3079, 6151, 12289, 24593,
  307. 			49157, 98317, 196613, 393241, 786433,
  308. 			1572869, 3145739, 6291469, 12582917, 25165843,
  309. 			50331653, 100663319, 201326611, 402653189, 805306457,
  310. 			1610612741, 3221225473, 4294967291
  311. 		}; //实际上是不可能扩到最大的 因为 2^32次方  哪怕是char类型都有4G了  指针都有16G了
  312. 		/*1Byte（字节）=8bit（位）
  313. 		1 KB = 1024 Byte
  314. 		1 MB = 1024 KB
  315. 		1 GB = 1024 MB
  316. 		1TB = 1024GB*/
  317.  
  318.  
  319. 		size_t i = 0;
  320. 		for (; i < __stl_num_primes; ++i)
  321. 		{
  322. 			if (__stl_prime_list[i] > prime)
  323. 				return __stl_prime_list[i];
  324. 		}
  325.  
  326. 		return __stl_prime_list[i];  //在表里依次遍历 找到比原先大的那个素数值
  327. 	}
  328.  
  329. 	const size_t MaxBucketSize() const  //统计桶的最大长度并返回  检测查找的效率   测试用的  不是刚需
  330. 	{
  331. 		size_t max = 0;
  332. 		for (size_t i = 0; i < _buckets.size(); ++i)
  333. 		{
  334. 			Node* cur = _buckets[i];
  335. 			size_t size = bucket_size(cur);
  336. 			printf("[%zd]->%zd\n", i, size); //打印所有桶的长度 让我们看到具体的分布情况  这样就可以测出查找的时间复杂度
  337. 			if (size > max) 	max = size;
  338. 		}
  339. 		return max;
  340. 	}
  341.  
  342. 	 size_t bucket(const K& key) const //返回key所在哈希桶的编号
  343. 	{
  344. 		Hash hash;//控制模出来的情况 因为可能会是字符串什么的
  345. 		size_t hashi = hash(key) % _buckets.size(); //找到这个点
  346. 		return hashi;
  347. 	}
  348.  
  349. 	 size_t bucket_size(size_t n) const  //返回这个桶有多少个元素
  350. 	 {
  351. 		 Node* cur = _buckets[n];
  352. 		 size_t size = 0;
  353. 		 while (cur)
  354. 		 {
  355. 			 ++size;
  356. 			 cur = cur->_next;
  357. 		 }
  358. 		 return size;
  359. 	 }
  360.  
  361. private:
  362. 	vector<Node*> _buckets; //指针数组  哈希桶集合
  363. 	size_t _n = 0;//记录有效元素的个数 
  364. };

字符串哈希函数算法

由于string很常用，所以库里面有默认支持string类型的哈希函数，将哈希函数转化成可以取模的整数

3.2 unordered_set的封装

  1. #pragma once
  2. #include"HashTable.h"
  3.  
  4. namespace cyx
  5. {
  6. 	template<class K , class Hash = HashFunc<K>> //不要再Hashtable里面传  会写死 这样自定义类型的key就没有办法解决了
  7. 	class unordered_set
  8. 	{
  9. 	public:
  10. 		struct SetKeyOfT
  11. 		{
  12. 			const K& operator()(const K& key)
  13. 			{
  14. 				return key;
  15. 			}
  16. 		};
  17.  
  18. 		~unordered_set()
  19. 		{
  20. 			 clear();
  21. 		}
  22.  
  23. 		//取类模板的内嵌类型 一定要用typename  不然无法区分这是一个类型还是成员变量 
  24. 		typedef typename HashTable<K, K,SetKeyOfT,Hash> ::const_iterator iterator; //set的迭代器不可被修改
  25. 		typedef typename HashTable<K, K, SetKeyOfT, Hash>::const_iterator const_iterator;
  26. 		iterator begin() //普通迭代器转化const迭代器 就会去调用那个拷贝构造
  27. 		{
  28. 			return _ht.begin();
  29. 		}
  30. 		iterator end()
  31. 		{
  32. 			return _ht.end();
  33. 		}
  34.  
  35. 		const_iterator begin() const
  36. 		{
  37. 			return _ht.begin();
  38. 		}
  39.  
  40. 		const_iterator end() const
  41. 		{
  42. 			return _ht.end();
  43. 		}
  44.  
  45. 		pair<iterator, bool> insert(const K& key)
  46. 		{
  47. 			return _ht.Insert(key);
  48. 		}
  49.  
  50. 		iterator find(const K& key)
  51. 		{
  52. 			return _ht.Find(key);
  53. 		}
  54.  
  55. 		bool erase(const K& key)
  56. 		{
  57. 			return _ht.Erase(key);
  58. 		}
  59.  
  60. 		void clear() 
  61. 		{
  62. 			_ht.clear();
  63. 		}
  64.  
  65. 		bool empty() const
  66. 		{
  67. 			return _ht.empty();
  68. 		}
  69.  
  70. 	private:
  71. 		HashTable<K, K, SetKeyOfT, Hash>  _ht ;
  72. 	};
  73. }

3.3 unordered_map的封装

  1. #pragma once
  2. #include"HashTable.h"
  3.  
  4. namespace cyx
  5. {
  6. 	template<class K,class V,class Hash = HashFunc<K>>
  7. 	class unordered_map
  8. 	{
  9. 	public:
  10. 		struct MapKeyOfT
  11. 		{
  12. 			const K& operator()(const pair<K,V>& kv) //帮助我们拿到key
  13. 			{
  14. 				return kv.first;
  15. 			}
  16. 		};
  17.  
  18. 		 ~unordered_map()
  19. 		{
  20. 			clear();
  21. 		}
  22.  
  23. 		//取类模板的内嵌类型 一定要用typename  不然无法区分这是一个类型还是成员变量 
  24. 		typedef typename HashTable<K, pair<const K, V>, MapKeyOfT,Hash> ::iterator iterator; //pair的key无论什么情况都不能修改 所以我们通过传const K控制
  25. 		typedef typename HashTable<K, pair<const K, V>, MapKeyOfT,Hash>::const_iterator const_iterator;
  26. 		typedef unordered_map<K, V, Hash> Self;
  27.  
  28. 		iterator begin()
  29. 		{
  30. 			return _ht.begin();
  31. 		}
  32. 		iterator end()
  33. 		{
  34. 			return _ht.end();
  35. 		}
  36.  
  37. 		const_iterator begin() const
  38. 		{
  39. 			return _ht.begin();
  40. 		}
  41.  
  42. 		const_iterator end() const
  43. 		{
  44. 			return _ht.end();
  45. 		}
  46.  
  47.  
  48. 		pair<iterator, bool> insert(const pair<K,V>& kv)
  49. 		{
  50. 			return _ht.Insert(kv);
  51. 		}
  52.  
  53. 		iterator find(const K& key) const
  54. 		{
  55. 			return _ht.Find(key);
  56. 		}
  57.  
  58. 		bool erase(const K& key)
  59. 		{
  60. 			return _ht.Erase();
  61. 		}
  62.  
  63. 		V& operator[](const K& key)  //重载方括号
  64. 		{
  65. 			pair<iterator, bool> ret = insert(make_pair(key, V()));
  66. 			return ret.first->second;
  67. 		}
  68. 		
  69.  
  70. 		void clear() 
  71. 		{
  72. 			_ht.clear();
  73. 		}
  74.  
  75. 		bool empty() const
  76. 		{
  77. 			return _ht.empty();
  78. 		}
  79.  
  80.  
  81. 		void swap(Self& s)
  82. 		{
  83. 			_ht.swap(s._ht);
  84. 		}
  85. 	private:
  86. 		HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht; 
  87. 	};

 3.4 自定义类型的key

  1. 	class Date
  2. 	{
  3. 		friend struct HashDate; //确保能够访问其私有成员
  4. 	public:
  5. 		Date(int year = 1900, int month = 1, int day = 1)
  6. 			: _year(year)
  7. 			, _month(month)
  8. 			, _day(day)
  9. 		{}
  10.  
  11. 		bool operator<(const Date& d)const
  12. 		{
  13. 			return (_year < d._year) ||
  14. 				(_year == d._year && _month < d._month) ||
  15. 				(_year == d._year && _month == d._month && _day < d._day);
  16. 		}
  17.  
  18. 		bool operator>(const Date& d)const
  19. 		{
  20. 			return (_year > d._year) ||
  21. 				(_year == d._year && _month > d._month) ||
  22. 				(_year == d._year && _month == d._month && _day > d._day);
  23. 		}
  24.  
  25. 		bool operator==(const Date& d) const
  26. 		{
  27. 			return _year == d._year
  28. 				&& _month == d._month
  29. 				&& _day == d._day;
  30. 		}
  31.  
  32. 		friend ostream& operator<<(ostream& _cout, const Date& d);
  33. 	private:
  34. 		int _year;
  35. 		int _month;
  36. 		int _day;
  37. 	};
  38.  
  39. 	ostream& operator<<(ostream& cout, const Date& d)
  40. 	{
  41. 		cout << d._year << "-" << d._month << "-" << d._day;
  42. 		return cout;
  43. 	}
  44.  
  45. 	struct HashDate //自定义类型的key就手动传一个
  46. 	{
  47. 		size_t operator()(const Date& d)
  48. 		{
  49. 			size_t hash = 0;
  50. 			hash += d._year;
  51. 			hash *= 31;
  52.  
  53. 			hash += d._month;
  54. 			hash *= 31;
  55.  
  56. 			hash += d._day;
  57. 			hash *= 31;
  58.  
  59. 			return hash;
  60. 		}
  61. 	};
  62.  
  63. 	// 一个类型要做unordered_map/unordered_set的key，要满足支持转换成取模的整形 和 ==比较
  64. 	
  65. 	// 一个类型要做map/set的key，要满足支持<比较
  66. 	/*if (cur->key < key)
  67. 	{}
  68. 	else if (key < cur->key)
  69. 	{}
  70. 	else
  71. 	{}*/
  72.  
  73.  
  74. 	//如果有些类不是你写的，并不支持上面的东西 但是你还是想要去比较怎么办呢？？   其实库里面还提供了一个仿函数  class Pred = equal_to<Key>//判断各个键值对相同的规则
  75.  
  76. 	void test_unordered_map4()
  77. 	{
  78. 		Date d1(2023, 3, 13);
  79. 		Date d2(2023, 3, 13);
  80. 		Date d3(2023, 3, 12);
  81. 		Date d4(2023, 3, 11);
  82. 		Date d5(2023, 3, 12);
  83. 		Date d6(2023, 3, 13);
  84.  
  85. 		Date a[] = { d1, d2, d3, d4, d5, d6 };
  86.  
  87. 		unordered_map<Date, int, HashDate> countMap;
  88. 		for (auto e : a)  ++countMap[e];
  89. 		for (auto& kv : countMap)  cout << kv.first << ":" << kv.second << endl;
  90. 	}

注意：

1、 一个类型要做unordered_map/unordered_set的key，满足支持转换成 取模的整形 和 ==比较
       一个类型要做map/set的key，要满足支持<比较 

2、但是如果该类不是你自己写的，我们没有办法直接去访问其私有成员，那就得再加一个模版参数class Pred = equal_to<Key> 。增加判断键值相同的规则。

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/886200
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号