【C++】——哈希

最新推荐文章于 2025-04-25 12:55:02 发布
原创 最新推荐文章于 2025-04-25 12:55:02 发布
· 1k 阅读 · 28 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#哈希算法 #c++ #算法 #c语言

文章目录

什么是哈希

哈希是一种特殊的存储结构，该结构能够通过某种函数使元素的存储位置与它的关键码之间能够建立映射的关系。
哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(散列表)。

哈希冲突

哈希冲突是哈希函数中不可避免的现象。
哈希冲突是指在使用哈希表进行数据的存储和查找时，不同的关键字通过哈希函数计算后得到相同的哈希值。
在这里插入图片描述
因为无法彻底解决哈希冲突，所以我们要尽可能设计出一个能将关键字均匀分布到哈希表空间中的的哈希函数。

两种简单的闭散列哈希函数

  1. 直接定址法：
    函数表示： H(key) = x * key + y
    优点：简单，均匀
    缺点：空间利用率低，在理想状态下即元素是连续的才不会发生碰撞
  2. 除留余数法：
    函数表示：Hash(key) = key% p(p<=m)，将关键字映射到哈希表地址
    m为哈希表中存储元素的数量上限，p为一个不大于哈希表长度m的质数，用于计算余数
    优点：简单，适用范围广

闭散列

闭散列也叫开放定址法，是哈希表解决冲突的一种方法。
当发生哈希冲突时，闭散列法使用特定的探测方法来找到下一个可用的空闲位置。探测方法可以是线性的、二次的或伪随机的等。

常用探测方法：

  1. 线性探测：
    从发生冲突的位置开始，依次向后探测，直到找到一个空闲位置为止。线性探测简单易懂，但可能会产生聚集现象（即连续的位置被占用后，后续的插入操作会越来越困难，导致查找时间增加）。
  2. 二次探测：
    按照一定的步长进行查找，以减少聚集现象的发生。例如：i + 1²->i + 2²->i + 3²…

在这里插入图片描述
在这里插入图片描述
如上图所示，当数据插入越多，冲突率越高，所以我们需要扩容，而扩容的判断条件，我们称作负载因子
负载因子越大，产生冲突的概率越高，增删查改的效率越低。负载因子越小，产生冲突的概率越低，增删查改的效率越高。一般负载因子超过0.7就需要进行扩容。

开散列

开散列也叫链地址法(开链法)，也是一种解决哈希表的方法。在哈希表中，具有相同地址的关键字归于一个集合，每个集合称为桶，桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中，所以又叫哈希桶。
在这里插入图片描述

开散列的负载因子没有限制，可以大于1。
负载因子越大，哈希冲突的概率越高，空间利用率越低。负载因子越小，哈希冲突的概率越低，空间利用率越低。

功能实现

哈希表的主要功能有：

  1. 插入
  2. 查找
  3. 删除

哈希表的结构

闭散列
在闭散列中，删除数据不能用覆盖的方式，应采用状态标记进行伪删除。
如果采用覆盖方式进行删除，即直接删除哈希表中某个位置的元素并用新元素覆盖它，那么将会破坏哈希表的完整性。因为其他元素可能依赖于这个位置的空闲状态来解决冲突，或者这个位置的元素可能与其他元素通过探测过程形成了某种“链式”关系。直接覆盖将会导致这些关系断裂，使得哈希表无法正确地进行查找和插入操作。

enum State
{
	EMPTY,//不存在数据
	EXIST,//存在数据
	DELETE//已删除
};
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};
template<class K, class V, class Hash = HashFunc<K>>// 模版特化，插入内容中会有详细介绍
class HashTable
{
	typedef HashData<K, V> Node;
public:
	//具体实现
private:
	vector<Node> _table;//哈希表
	size_t _n = 0;//有效数据个数
};

开散列
参考链表结构

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 HashData<K, V> Node;
public:
    //具体实现
private:
    vector<Node*> _table;//哈希表
    size_t _n = 0;//有效数据个数
};

插入

闭散列
在插入以前，我们要考虑不同类型的数据插入，全部转换为整数处理，比较特殊的是string类型，因为string类型并不能直接转换为整数。
我采用模版特化的方式，为string类型提供一个特定的哈希函数实现。

template<class K>
struct HashFunc         //仿函数，将其他类型转化为整形
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
template<>     //特化
struct HashFunc<string>    //string类的不可以直接转化为整形，需要特殊处理
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}
		return hash;
	}
};

bool insert(const K& kv)
{
	size_t n = _table.size();
	//检查是否扩容
	if (10 * _n / n >= 7)
	{
		//直接建立一个新表
		HashTable<K, V, Hash> newtable;
		newtable._table.resize(n * 2);
		//复用插入的逻辑
		for (size_t i = 0; i < n; i++)
		{
			if (_table[i]._state == EXIST)//该位置有元素才转移
			{
				newtable.insert(_table[i]._kv);
			}
		}
		//交换新旧表
		_tables.swap(newtable._tables);;
	}
	//根据哈希函数，计算位置
	Hash hs;
	size_t hashi = hs(kv) % n;

	//检查是否有哈希冲突问题
	while (_table[hashi]._state == EXIST)
	{
		++hashi;
		hashi %= n;//实现下标的环绕
	}
	//插入元素，修改状态
	_table[hashi]._kv = kv;
	_table[hashi]._state = EXIST;
	++_n;
	return true;
}

开散列
因为开散列使用的是链表来存储相同哈希值的键值对，每个桶里都有一个指向链表的指针，所以我们对于每个键值对都需要动态地分配内存，那么就需要构造和析构函数来管理内存。

HashTable()
	:_tables(11)
	, _n(0)
{}

~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;
	size_t size = _table.size();
	//检查扩容
	if (_n == size)//节点个数等于桶的数量时，进行扩容
	{
		//为了节省开销，不再重新开辟新节点，直接映射原来的节点，将原来的映射取消
		vector<Node*> newtable(size * 2, nullptr);
		size_t newsize = newtable.size();
		for (size_t i = 0; i < size; i++)
		{
			Node* cur = _table[i];
			while (cur)
			{
				size_t hashi = hs(cur->_kv) % newsize;//元素对应的新表中的位置

				Node* next = cur->_next;//记录当前桶的下一个元素

				//头插连接到新桶
				cur->_next = newtable[hashi];
				newtable[hashi] = cur;

				cur = next;
			}
			_table[i] = nullptr;
		}
		swap(_table, newtable);
	}
	size_t hashi = hs(kv) % _table.size();

	//头插连接
	Node* newnode = new Node(kv);
	newnode->_next = _table[hashi];
	_table[hashi] = newnode;
	++_n;
	return true;
}

查找

闭散列
直接用线性探测一一比较就行，如果查找到空了，就是没找到

Node* find(const K& key)
{
	//根据key获取表中的位置
	Hash hs;
	size_t hashi = hs(key) % _table.size();
	while (_table[hashi]._state != EMPTY)
	{
		if (_table[hashi]._state == EXIST
			&& _table[hashi]._data == key)
		{
			return &_table[hashi];
		}
		hashi++;
		hashi %= _table.size();
	}
	return nullptr;
}

开散列
开散列就遍历链表好了

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

删除

闭散列
进行伪删除

	bool erase(const K& key)
	{
		int hashi = find(key);
		if (hashi != -1)
		{
			_table[hashi]._state = DELETE;//状态设置为删除
			--_n;//个数减少
			return true;
		}
		return false;
	}

开散列
这里删除要分两种种情况

  1. 当前桶是否只有这一个元素
  2. 多个元素时，删除链表中的节点要连接删除节点前后的节点（要记录前驱节点）
bool erase(const K& key)
{
	Hash hs;
	size_t hashi = hs(key) % _table.size();
	Node* cur = _table[hashi];
	Node* prev = nullptr;
	while (cur)
	{
		if (cur->_data == key)
		{
			if (prev == nullptr)//桶中只有一个元素
			{
				_table[hashi] = nullptr;
			}
			else
			{
				prev->_next = cur->_next;//连接前驱和后继节点
			}
			delete cur;
			_n--;
			return true;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
	return false;
}

完整代码

闭散列

enum State
{
	EMPTY,//不存在数据
	EXIST,//存在数据
	DELETE//已删除
};
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};
template<class K>
struct HashFunc         //仿函数，将其他类型转化为整形
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
template<>     //特化
struct HashFunc<string>    //string类的不可以直接转化为整形，需要特殊处理
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}
		return hash;
	}
};



template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
	typedef HashData<K, V> Node;
public:
	
	//具体实现
	bool insert(const K& kv)
	{
		size_t n = _table.size();
		//检查是否扩容
		if (10 * _n / n >= 7)
		{
			//直接建立一个新表
			HashTable<K, V, Hash> newtable;
			newtable._table.resize(n * 2);
			//复用插入的逻辑
			for (size_t i = 0; i < n; i++)
			{
				if (_table[i]._state == EXIST)//该位置有元素才转移
				{
					newtable.insert(_table[i]._kv);
				}
			}
			//交换新旧表
			_tables.swap(newtable._tables);;
		}
		//根据哈希函数，计算位置
		Hash hs;
		size_t hashi = hs(kv) % n;

		//检查是否有哈希冲突问题
		while (_table[hashi]._state == EXIST)
		{
			++hashi;
			hashi %= n;//实现下标的环绕
		}
		//插入元素，修改状态
		_table[hashi]._kv = kv;
		_table[hashi]._state = EXIST;
		++_n;
		return true;
	}


	Node* find(const K& key)
	{
		//根据key获取表中的位置
		Hash hs;
		size_t hashi = hs(key) % _table.size();
		while (_table[hashi]._state != EMPTY)
		{
			if (_table[hashi]._state == EXIST
				&& _table[hashi]._data == key)
			{
				return &_table[hashi];
			}
			hashi++;
			hashi %= _table.size();
		}
		return nullptr;
	}

	bool erase(const K& key)
	{
		int hashi = find(key);
		if (hashi != -1)
		{
			_table[hashi]._state = DELETE;//状态设置为删除
			--_n;//个数减少
			return true;
		}
		return false;
	}

private:
	vector<Node> _table;//哈希表
	size_t _n = 0;//有效数据个数
};

开散列

class HashTable
{
    typedef HashData<K, V> Node;
public:
	HashTable()
		:_tables(11)
		, _n(0)
	{}

	// 拷贝构造和赋值重载也需要

	~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;
		}
	}

    //具体实现
	typedef HashNode<K, V> Node;
	
	bool insert(const pair<K, V>& kv)
	{
		Hash hs;
		size_t size = _table.size();
		//检查扩容
		if (_n == size)//节点个数等于桶的数量时，进行扩容
		{
			//为了节省开销，不再重新开辟新节点，直接映射原来的节点，将原来的映射取消
			vector<Node*> newtable(size * 2, nullptr);
			size_t newsize = newtable.size();
			for (size_t i = 0; i < size; i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					size_t hashi = hs(cur->_kv) % newsize;//元素对应的新表中的位置

					Node* next = cur->_next;//记录当前桶的下一个元素

					//头插连接到新桶
					cur->_next = newtable[hashi];
					newtable[hashi] = cur;

					cur = next;
				}
				_table[i] = nullptr;
			}
			swap(_table, newtable);
		}
		size_t hashi = hs(kv) % _table.size();

		//头插连接
		Node* newnode = new Node(kv);
		newnode->_next = _table[hashi];
		_table[hashi] = newnode;
		++_n;
		return true;
	}

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

	bool erase(const K& key)
	{
		Hash hs;
		size_t hashi = hs(key) % _table.size();
		Node* cur = _table[hashi];
		Node* prev = nullptr;
		while (cur)
		{
			if (cur->_data == key)
			{
				if (prev == nullptr)//桶中只有一个元素
				{
					_table[hashi] = nullptr;
				}
				else
				{
					prev->_next = cur->_next;//连接前驱和后继节点
				}
				delete cur;
				_n--;
				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}
private:
    vector<Node*> _table;//哈希表
    size_t _n = 0;//有效数据个数
};
C++ 哈希
lmw3020083657的博客
04-01 448
哈希 ，闭散列，开散列，封装unordered_map和unordered_set，
【C++】哈希
须知少日拏云志，曾许人间第一流。
04-15 2437
讲解哈希结构、哈希碰撞、开散列和闭散列及其模拟实现。
C++——哈希
2302_80007250的博客
09-08 1347
undered_map是存储键值对<key,value>的关联式容器。与map不同，undered_map存储的key没有顺序，但同样是通过key索引得到value。undered_map中的键值key不可修改且唯一。undered_map支持[ ]访问，下标为键值key。如果key不存在，那么会将key进行插入，对应的value为默认值。undered_map的通过key访问value的效率比map快函数声明功能介绍构造不同格式的undered_map对象。
【重走C++学习之路】19、哈希
最新发布
MeiYu_123的博客
04-25 902
哈希概念，哈希函数，哈希冲突以及解决方法
C++【哈希】
芊樱烛渊的博客
11-14 1719
假如从底层实现上去取名字的话，map和set的实现可以分为hash实现和tree的实现最大的区别是unordered系列提供的是单向的迭代器。
【C++】---哈希算法
weixin_75128035的博客
08-27 1769
简单的说，就是运用->哈希思想，而形成的数据结构！就是找出各个数据对应的储存位置的转换公式！按照这种方法查找不用拿key多次比较，不用像链表2叉树等等那些数据结构进行多次比较才会查找到结果。因此查找的速度比较快。哈希冲突：就是说，不同的数据，通过哈希函数，来计算出它所对应的映射位置的时候，位置相同，就是哈希冲突！比如说这里的10001和11，%10之后，他们所得的值都是1，都应该放在下标为1的位置，这就是哈希冲突！引起哈希冲突的原因：哈希函数设计不合理。
C++——哈希结构
大学生一枚
08-03 939
1.unordered_map是储存键值对的关联式容器，其允许通过key快速查找到对应的value，和map非常相似，但是底层实现完全不同。2.unoredered_map没有对进行排序，而是映射一个对象，其内容与其键相关联，键和映射值的类型可能不同。构造一种储存结构，通过某种函数使元素的储存位置与他的关键码建立一一映射的关系，那么在查找该元素的时候很快就能找到。就是用我们插入的数据模上哈希表的长度，得出的余数，就是我们得到的插入位置的下标；
c++——哈希
蜗@牛的博客
07-15 2309
概念 哈希是一种搜索数据结构，不过哈希搜索不同于顺序搜索和二叉搜索的是：哈希可以不经过任何比较，一次直接从表中得到要搜索的元素。它是通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数就可以直接找到该元素。 哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表 (Hash Table)(或者称散列表) 。 哈希冲突 哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间的大小。
【C++ —— 哈希】哈希原理 | 哈希表的模拟实现 | 模拟实现封装unordered_map和unordered_set
qq_55953229的博客
05-26 1202
本文参考文档：https://legacy.cplusplus.com/reference/unordered_map/
C++——哈希表与哈希查找
Wannna的博客
11-28 2281
1、哈希表类的哈希函数采用除留余数法哈希函数； 2、解决哈希冲突的函数采用开放定址法中的线性探察法。 3、建立一个由10个数据元素组成的集合； #include"iostream" using namespace std; #define m 15 //m是表长 #define n 13 //n是选择的质因子 typedef int KeyType; //关键字key类型 typedef i...
C++——哈希unordered_set/unordered_map的封装
2301_80687320的博客
09-16 1308
unordered_set和map的介绍在上一篇博客有所提到C++——深部解析哈希在编程的世界里，数据结构是构建高效、可扩展程序的基石。C++作为一门功能强大的编程语言，提供了丰富的标准库容器，其中unordered_set和map以其高效的查找和插入操作而广受欢迎。然而，尽管这些容器功能强大，直接使用它们有时可能不够直观或灵活，特别是在需要特定行为或扩展功能时。因此，封装这些容器，以提供更符合特定需求的接口，成为了一种常见的编程实践。
哈希函数　哈希表c/c++
04-13
数据结构中的哈希表，用ｃ＋＋写的，通过老师验证
哈希算法C++实现
02-26
哈希表算法C++实现 SGI 哈希表是一个线性存储结构，其关键是哈希函数与哈希值算法
哈希算法的实现c++
05-10
哈希算法的实现c++
C++:哈希
WHLOOK
08-11 755
1.基本概念 　　哈希一般用来快速查找，通过hash函数将输入的键值（key）映射到某一个地址，然后就可以获得该地址的内容。 同样，如果要储存一对值（键值和数据），则也是通过hash函数获得地址来存入。见图例：   　　不过这其中会出现一些问题，最常见的是出现冲突。就是输入不同的key，经过hash之后得到同样的值，也就是在同一个地址要储存不同的data， 例如使用上图的hash，输
【C++】哈希（hash）
m0_72563041的博客
05-15 1527
哈希概念，哈希冲突，哈希函数
一篇文章搞懂C++实现哈希算法
weixin_73570479的博客
05-13 4271
哈希算法，也称为散列算法，是一种从任意长度的输入数据创建固定大小输出的方法，这种输出通常被称为“哈希值”、“散列值”或简单地“哈希”。在计算机科学中，哈希算法主要用于快速数据查找和数据结构中的高效数据管理，如哈希表。哈希也是加密和数据完整性验证的基础。哈希算法通过一个称为哈希函数的数学过程来运作。这个函数接受输入（称为“预映射值”）并返回一个通常较短、固定长度的哈希值。这个哈希值在理想情况下为每个不同的输入值提供一个唯一的标识（尽管在实际中这并不总是可能的）。
拉链法解决哈希冲突——哈希表实现解析
"这篇资源主要讨论了哈希表（散列表）中冲突处理的一种方法——拉链法。通过使用分离链接技术，将具有相同哈希值的元素组织成链表，以便于存储和检索。" 在计算机科学中，哈希表是一种数据结构，它提供了快速的查找...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值