C++ 哈希表模拟实现(补充)

已于 2022-08-30 11:24:05 修改
阅读量547 收藏
点赞数 1
分类专栏： C++进阶 文章标签： c++ 哈希算法 哈希表
于 2022-08-29 23:36:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61548909/article/details/126591355
版权

目录

1.引例：两个练习题

2.定义基本的存储结构

3.Insert()

4.Erase()

5.string为参数的情况

6.添加类模板 

7.整体代码

1.引例：两个练习题

2.定义基本的存储结构

#pragma once
namespace CloseHash
{
	template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;
	};

	template<class K,class V>
	class HashTable
	{
	private:
		HashData* _table;
		size_t _size;
		size_t _capacity; //用于增容
	};
}

后者直接用vector存储

#pragma once
#include<vector>
#include<iostream>
using namespace std;
namespace CloseHash
{
	template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;
	};

	template<class K,class V>
	class HashTable
	{
    public://待写
	private:
		//HashData* _table;
		//size_t _size;
		//size_t _capacity; //用于增容
		vector<HashData> _table;
		size_t _n;//存储的有效数据的个数
	};
}

3.Insert()

如何判断一个位置是空还是满？若删除其中一个值，用空值去标识，下一次找后面冲突的值找不到了。前一个冲突的值被删了，导致不连续了，找到空就结束了。

 提供一个状态标识即可

 namespace CloseHash
{
	enum State//状态
	{
		EMPTY,
		EXITS,
		DELTE,
	};
	template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;//默认状态给空
	};

	template<class K,class V>
	class HashTable
	{
	public://待写函数
	private:
		//HashData* _table;
		//size_t _size;
		//size_t _capacity; //用于增容
		vector<HashData> _table;
		size_t _n;//存储的有效数据的个数
	};
}
 bool Insert(const pair<K, V>& kv)
{
	HashData<K, V>* ret = Find(kv, first);
	if (ret)
	{
		return false;
	}
	//判断是否满
	//计算负载因子，大于0.7就增容
	//if (_n*10 / _table.size() > 7)
	if (_tabale.size() == 0)
	{
		_table.resize(10);
	}
	else if ((double)_n / (double)_table.size() > 0.7)
	{
		//方法一，不足之处在于要重复写插入逻辑
		//vector<HashData>newtable;
		//newtable.resize(_table.size*2);  新表增容，增到旧表的二倍
		//for (auto& e : _table)
		//{
		//	if (e._table == EXITS)
		//	{
		//		//重新计算放到newtable中去
		//		//跟下面插入逻辑类似
		//	}
		//}
		//_table.swap(newtable);

		HashTable<K, v>newHT;
		newHT._table.resize(_table.size() * 2);
		for (auto& e : _table)
		{
			if (e._state == EXITS)
			{
				newHT.Insert(e._kv);
			}
		}
		_table.swap(newHT._table);
	}

	size_t start = kv.first % _table.size();//不能%_table.capacity()
	size_t index = start;

	//探测后面的位置 -- 线性探测或二次探测
	size_t i = 1;
	while (_table[index]._state == EXITS)
	{
		index += start + i;//此处的线性探测想改成二次探测将i改为i*i即可
		index %= _table.size();
		++i;
	}

	_table[index]._kv = kv;
	_table[index]._state = EXITS;
	++_n;

	return true;
}

HashData<K, V>* Find(const K& key)
{
	//排除0的情况
	if (_table.size() == 0)
	{
		return nullptr;
	}
	size_t start = key % _table.size();
	size_t index = start;
	size_t i = 1;
	while (_table[index]._state != EMPTY)
	{
		if (_table[index]._state == EXITS//避免已经删除的元素仍可被寻找的情况
			&& _table[index]._kv.first == key)
		{
			return &_table[index];
		}
		inded = start + i;
		index %= _table.size();
		++i;
	}
	return nullptr;
}

4.Erase()

bool Erase(const K& key)
{
	HashData<K, V>* ret = Find(key);
	if (ret == nullptr)
	{
		return false;
	}
	else
	{
		ret->_state = DELETE;
		return true;
	}
}

5.string为参数的情况

若出现下面测试代码的情况，如何更改？

void TestHashTable2()
{
	string a[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "橘子", "苹果" };
	HashTable<string, int> ht;
	for (auto str : a)//string作k的情况
	{
		auto ret = ht.Find(str);
		if (ret)
		{
			ret->_kv.second++;
		}
		else
		{
			ht.Insert(make_pair(str, 1));
		}
	}
}

所有要取模的地方添加仿函数，该仿函数的功能就是将数据转换成整型。

struct IniHashFunc
{
	int operator()(int i)
	{
		return i;
	}
};

 

特别的，将字符串转换成整型的仿函数仍存在问题。采用字符串哈希算法的思路改正即可    各种字符串Hash函数 - clq - 博客园

以此类推，K为不同类型元素的情况写对应的仿函数即可

思考：

 一个类型去作map/set的Key有什么要求？ 能支持比较大小

一个类型去作unordered_map/unordered_set的Key有什么要求？  能支持转换成整型+相等比较

6.添加类模板 

可以转化成整型的数据采用下面模板，返回值为int

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

当K是string时不会走原生的模板，采用特化单独创建一个模板

template<>
struct Hash<string>
{
	//字符串转成对应的整型，整型才能取模算映射位置
	//期望->字符串不同，转出的整型值尽量不同
	size_t operator()(const string& s)
	{
		//return s[0];  存在int insert类似首字母相同的情况

		//存在abcd,bcad或abbb.abca的情况(ascii码和相同的情况)
		size_t value = 0;
		for (auto ch : s)
		{
			value += ch;
			value *= 131;//采用BKDRHash算法的思想 乘以131
		}
		return value;
	}
};

使用类模板后不同的数据类型会调用不同类型的仿函数 

 此时可以省略仿函数，参数自动使用隐式类型转换

 

7.整体代码

#pragma once
#include <vector>
#include <iostream>
using namespace std;

namespace CloseHash
{
	enum State
	{
		EMPTY,
		EXITS,
		DELETE,
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;  // 状态
	};

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

	// 特化
	template<>
	struct Hash<string>
	{
		// "int"  "insert" 
		// 字符串转成对应一个整形值，因为整形才能取模算映射位置
		// 期望->字符串不同，转出的整形值尽量不同
		// "abcd" "bcad"
		// "abbb" "abca"
		size_t operator()(const string& s)
		{
			// BKDR Hash
			size_t value = 0;
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}

			return value;
		}
	};

	template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
	public:
		bool Insert(const pair<K, V>& kv)
		{
			HashData<K,V>* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}

			// 负载因子大于0.7，就增容
			//if (_n*10 / _table.size() > 7)
			if (_table.size() == 0)
			{
				_table.resize(10);
			}
			else if ((double)_n / (double)_table.size() > 0.7)
			{
				//vector<HashData> newtable;
				// newtable.resize(_table.size*2);
				//for (auto& e : _table)
				//{
				//	if (e._state == EXITS)
				//	{
				//		// 重新计算放到newtable
				//		// ...跟下面插入逻辑类似
				//	}
				//}

				//_table.swap(newtable);

				HashTable<K, V, HashFunc> newHT;
				newHT._table.resize(_table.size() * 2);
				for (auto& e : _table)
				{
					if (e._state == EXITS)
					{
						newHT.Insert(e._kv);
					}
				}

				_table.swap(newHT._table);
			}

			HashFunc hf;
			size_t start = hf(kv.first) % _table.size();
			size_t index = start;

			// 探测后面的位置 -- 线性探测 or 二次探测
			size_t i = 1;
			while (_table[index]._state == EXITS)
			{
				index = start + i;
				index %= _table.size();
				++i;
			}

			_table[index]._kv = kv;
			_table[index]._state = EXITS;
			++_n;

			return true;
		}

		HashData<K,V>* Find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}

			HashFunc hf;
			size_t start = hf(key) % _table.size();
			size_t index = start;
			size_t i = 1;
			while (_table[index]._state != EMPTY)
			{
				if (_table[index]._state == EXITS 
					&& _table[index]._kv.first == key)
				{
					return &_table[index];
				}

				index = start + i;
				index %= _table.size();
				++i;
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
			{
				return false;
			}
			else
			{
				ret->_state = DELETE;
				return true;
			}
		}

	private:
	/*	HashData* _table;
		size_t _size;
		size_t _capacity;*/
		vector<HashData<K, V>> _table;
		size_t _n = 0;  // 存储有效数据的个数
	};

	void TestHashTable1()
	{
		int a[] = { 1, 5, 10, 100000, 100, 18, 15, 7, 40};
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		auto ret = ht.Find(100);
		if (ret)
		{
			cout << "找到了"<<endl;
		}
		else
		{
			cout << "没有找到了" << endl;
		}

		ht.Erase(100);

		ret = ht.Find(100);
		if (ret)
		{
			cout << "找到了" << endl;
		}
		else
		{
			cout << "没有找到了" << endl;
		}
	}

	struct stringHashFunc
	{
		// "int"  "insert" 
		// 字符串转成对应一个整形值，因为整形才能取模算映射位置
		// 期望->字符串不同，转出的整形值尽量不同
		// "abcd" "bcad"
		// "abbb" "abca"
		size_t operator()(const string& s)
		{
			// BKDR Hash
			size_t value = 0;
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}

			return value;
		}
	};

	void TestHashTable2()
	{
		string a[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "橘子", "苹果" };
		HashTable<string, int> ht;
		for (auto str : a)
		{
			auto ret = ht.Find(str);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				ht.Insert(make_pair(str, 1));
			}
		}
	}

	struct Student
	{
		// ...
	};

	struct StudentHashFunc
	{
		size_t operator()(const Student& kv)
		{
			// 如果是结构体
			// 1、比如说结构体中有一个整形，基本是唯一值 - 学号
			// 2、比如说结构体中有一个字符串，基本是唯一值 - 身份证号
			// 3、如果没有一项是唯一值，可以考虑多项组合
			size_t value = 0;
			// ...
			return value;
		}
	};

	void TestHashTable3()
	{
		string a[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "橘子", "苹果" };
		// 任意类型都可以做key，跟上一个把这个类型对象转换成整形的仿函数即可
		HashTable<Student, int, StudentHashFunc> ht;
	}

	void TestStringHashFunc()
	{
		stringHashFunc hf;
		cout << hf("insert")<<endl;
		cout << hf("int") << endl<<endl;

		cout << hf("abcd") << endl;
		cout << hf("bacd") << endl << endl;

		cout << hf("abbb") << endl;
		cout << hf("abca") << endl << endl;
	}
}

ScarboroughFair#
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表C++实现--hash_table
zhou753099943的专栏
05-31 5580
1、hash_table.h #include 3 #include 4 #include 5 #include 6 #include 7 using namespace std; 8 9 struct table_node 10 { 11 int _key; 12 string _value; 13 struct tabl
Hash表（C++实现）
lovecontry
08-20 439
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,...
C++ hash table 的编程实现
a130737的专栏
08-21 8743
关于Hash Table， 总结如下：
哈希表的C++实现
蒻菜_羊羊羊的专栏
04-06 460
#include using namespace std; typedef int KeyType; //设关键字域为整形,需要修改类型时，只需修改这里就可以 const int NULLKEY=0; //NULLKEY表示该位置无值 int c=0; //用来统计冲突次数 struct Elemtype //
C++哈希表的实现
Howl_1的博客
01-23 1268
本篇文章为笔者的读书笔记，未经允许请勿转载。本文主要讲的哈希表的创建和使用。哈希表是一种数据结构，用于存储和检索数据。它通过使用哈希函数将键值对映射到存储桶中，从而实现快速的数据访问。哈希表的作用是提供高效的查找、插入和删除操作。它的时间复杂度是常数级别的，因此在大量数据中能够快速定位需要的数据。哈希表的缺点是数组创建后难于扩展，当数组负载因子过大时就会扩容，性能会受到很大的影响。
信息学奥赛培训教程C++版.doc
02-18
此外，教程还会涉及数据结构，如链表、栈、队列、树（包括二叉树、平衡树如AVL和红黑树）以及哈希表。这些数据结构对于高效地存储和处理数据至关重要。 在实际问题解决部分，教程将通过实例分析，教导如何将实际...
model_implementations
04-17
常见的数据结构包括数组、链表、栈、队列、树（如二叉树、AVL树、红黑树）、图、哈希表等。在C++中，标准模板库(STL)提供了容器如vector、list、deque、set、map等，它们实现了上述许多数据结构。 2. **算法**: ...
2007年11月csai系分辅导模拟试题08分析与解答.rar
12-20
1. **基础算法与数据结构**：如排序算法（快速排序、归并排序等）、搜索算法（深度优先搜索、广度优先搜索等）以及常见数据结构（链表、树、图、堆、哈希表等）的实现和应用。 2. **人工智能**：包括机器学习的基础...
数据结构的一些课件
04-10
课件可能包含哈希表、二分查找树等，以及它们在动态查找中的优势。 6. **第九章 动态查找表**：可能是对第八章的深入或补充，可能会讨论其他查找算法，如B树、B+树等，这些在数据库索引和文件系统中广泛应用。 7. ...
计算机实验素材.rar
11-15
其次，数据结构的示例可能涵盖数组、链表、栈、队列、树、图等基本结构，以及哈希表、堆、图算法等高级结构。每个数据结构都有其特定的应用场景，通过实例化这些数据结构，学生可以理解它们在解决问题时的优势和局限...
C++实现哈希表
m0_43424329的博客
12-28 215
c++实现哈希表
哈希表的应用(C++实现)
热门推荐
08-18 2万+
问题描述：设计哈希表实现电话号码查询系统，实现下列功能： (1) 假定每个记录有下列数据项：电话号码、用户名、地址。 (2) 一是从数据文件old.txt(自己现行建好)中读入各项记录，二是由系统随机产生各记录，并且把记录保存到new.txt文件中以及显示到屏幕上，记录条数不要少于30，然后分别以电话号码和用户名为关键字建立哈希表。 (3) 分别采用伪随机探测再散列法和再哈希法解决冲突。
C++算法之Hash表的代码
Weldon141的博客
01-10 442
在代码过程，把做工程过程较好的一些代码段做个珍藏，下面资料是关于C++算法之Hash表的代码，应该是对大家有所用。 typedef struct _NODE { int data; }NODE; typedef struct _HASH_TABLE { }HASH_TABLE; b）创建hash表 { memset(pHashTbl, 0, sizeof(HASH_TABLE)); return pHashTbl; } c）在hash表当中寻找数据 { if(NULL == pHashTbl) retur
哈希表C++简单实现
weixin_43606861的博客
02-28 8010
1.什么是哈希表 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。 1.1 哈希函数 也叫散列函数，即：根据key,计算出key对应记录的储存位置 position = f(key) 散列函数满足以下的条件： 1、对输入值运算，得到一个固定长度的摘要(Hash val...
【C++】数组插入哈希表
看，未来的博客
12-17 942
标题内容虽然简单，但是我还是更愿意相信好记性不如烂笔头。 unordered_map<int,int[10]> 这样就没戏了。 可以这样： unordered_map<int,int*> 也可以这样： unordered_map<int,vector<int>> 作为我个人比较推荐第二种，最喜欢第一种，可惜第一种插不进去，我做了测试： #include<iostream> #include<unordered_map> usin
哈希表
栎梓天冲的专栏
04-08 825
转自：http://www.tuicool.com/articles/BVZfiy 定义 一般的线性表、树，数据在结构中的相对位置是 随机 的，即和记录的关键字之间不存在确定的关系，因此，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较“的基础上，查找的效率依赖于查找过程中所进行的比较次数。 若想能直接找到需要的记录，必须在记录的存储位置和它的关键字之间建立一个确
什么是哈希表
qq_44719229的博客
10-09 515
什么是哈希表 哈希表 是 Hash Table 一词的中文翻译，算法书里通常称这种数据结构为「散列表」。之所以称之为 散列表 和这种数据结构的存储方式有关，每个按序进入的数据经过 散列函数 的计算后会无序的分布在哈希表不同的位置，这是与数组、链表等有序结构所不同的。 哈希表实际上是数组的一种扩展。在哈希表中通过 哈希函数 我们可以将数字、字符串等数据中比较有代表性的数据作为 键值 转换成数组的 索...
查验身份证
HASHMOTO的博客
02-27 795
一个合法的身份证号码由 17 位地区、日期编号和顺序编号加 1 位校验码组成。校验码的计算规则如下：
5、Hash表应用（必做）（查找）
m0_54070377的博客
10-15 302
5、Hash表应用（必做）（查找）
C++哈希表代码实现
最新发布
10-15
好的，以下是一个简单的C++哈希表代码实现： ```c++ #include #include using namespace std; class HashTable { private: vector, int>>> table; int size; int hash(int key) { return key % size; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值