详解—[C++数据结构]—哈希＜哈希表&&哈希桶＞

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

一.unordered系列容器

1.1 unordered_map

官方文档介绍
unordered_map - C++参考 (cplusplus.com)

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. 它的迭代器至少是前向迭代器

1.2 unordered_set

官方文档介

unordered_set - C++ Reference (cplusplus.com)

同理,unordered_set和set的用法也基本一致,这里就不多做介绍了如果你不知道map和set的用法,请
先看这篇文章:

详解STL库—map和set-CSDN博客

二. 底层结构

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

2.1 哈希概念

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

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

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

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

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素55，会出现什么问题？

2.2 哈希冲突

对于两个数据元素的关键字Ki 和 Kj(i != j)，有Ki != Kj ，但有：Hash(Ki) == Hash(Kj)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

2.3 解决哈希冲突

解决哈希冲突两种常见的方法是：闭散列和开散列

2.3.1 闭散列

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

寻找下一个空位置的方法有很多,如

1. 线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
2. 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是以二次方的方式往后找位置

2.3.2 线性探测的实现哈希表

1.哈希表的结构代码

实现线性探测的哈希表，我们先把整个结构框架写出来

enum State
{
	EMPTY,
	EXIST,
	DELETE
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state;
	HashData(const pair<K, V>& kv = make_pair(0, 0))
		:_kv(kv)
		,_state(EMPTY)
	{ }
};

template<class K, class V>
class HashTable
{
private:
	vector<HashData<K, V>> _table;//数组中存储HashData封装的数据
	size_t _size = 0; //有效数据的个数
};

2.哈希表代码

bool insert(const pair<K, V>& kv)
{
	if (_table.size() == 0 || 10 * _size / _table.size() >= 7) // 扩容
	{
		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		HashTable<K, V> newHT;
		newHT._table.resize(newSize);
		// 旧表的数据映射到新表
		for (auto e : _table)
		{
			if (e._state == EXIST)
			{
				newHT.insert(e._kv);
			}
		}
		_table.swap(newHT._table);
	}
	size_t index = kv.first % _table.size();//不能模capacity,如果模出来的数大于size了还插入进去了会报错
	//线性探测
	while (_table[index]._state == EXIST)
	{
		index++;
		index %= _table.size();//过大会重新回到起点
	}
	_table[index]._kv = kv;
	_table[index]._state = EXIST;
	_size++;
	return true;
}

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

	size_t index = key % _table.size();//负数会提升成无符号数,所以负数不影响结果,但是string类不能取模,需要加入一个仿函数
	size_t start = index;
	while (_table[index]._state != EMPTY)
	{
		if (_table[index]._kv.first == key && _table[index]._state == EXIST)
			return &_table[index];
		index++;
		index %= _table.size();
		if (index == start)//全是DELETE时,必要时会break
			break;
	}
	return nullptr;
}

bool erase(const K& key)
{
	HashData<K, V>* ret = find(key);
	if (ret)
	{
		ret->_state = DELETE;
		--_size;
		return true;
	}
	return false;
}

2.4 开散列

2.4.1. 开散列概念

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

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

2.4.2 哈希桶模拟实现

1.哈希桶的结构代码

首先先写出结构框架

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;
private:
	vector<Node*> _table;
	size_t _size = 0;//有效数据个数
};

2.哈希桶的增删查

bool insert(const pair<K, V>& kv)
{
	//去重+扩容
	if (find(kv.first))
		return false;
	//负载因子到1就扩容
	if (_size == _table.size())
	{
		vector<Node*> newT;
		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		newT.resize(newSize, nullptr);
		//将旧表中的节点移动到新表
		for (int i = 0; i < _table.size(); i++)
		{
			Node* cur = _table[i];
			while (cur)
			{
				Node* next = cur->_next;
				size_t hashi = cur->_kv.first % newT.size();
				cur->_next = newT[hashi];
				newT[i] = cur;
				cur = next;
			}
			_table[i] == nullptr;
		}
		_table.swap(newT);
	}
	size_t hashi = kv.first % _table.size();
	//头插
	Node* newnode = new Node(kv);
	newnode->_next = _table[hashi];
	_table[hashi] = newnode;
	++_size;
	return true;
}

Node* find(const K& key)
{
	if (_table.size() == 0)
		return nullptr;
	size_t hashi = key % _table.size();
	Node* cur = _table[hashi];
	while (cur)//走到空还没有就是没用此数据
	{
		if (cur->_kv.first == key)
			return cur;
		cur = cur->_next;
	}
	return nullptr;
}

bool erase(const K& key)
{
	Node* ret = find(key);
	if (ret == nullptr)
		return false;
	size_t hashi = key % _table.size();
	Node* cur = _table[hashi];
	Node* prev = nullptr;
	while (cur && cur->_kv.first != key)//找到要删除的节点
	{
		prev = cur;
		cur = cur->_next;
	}
	Node* next = cur->_next;
	if (cur == _table[hashi])//注意头删的情况
		_table[hashi] = next;
	else
		prev->_next = next;
	delete cur;
	cur = nullptr;
	_size--;
	return true;
}

三、开散列的思考

3.1. 只能存储key为整形的元素，其他类型怎么解决？

// 哈希函数采用处理余数法，被模的key必须要为整形才可以处理，此处提供将key转化为整形的方法
// 整形数据不需要转化
template<class T>
class DefHashF
{
public:
	size_t operator()(const T& val)
	{
		return val;
	}
};
// key为字符串类型，需要将其转化为整形
class Str2Int
{
public:
	size_t operator()(const string& s)
	{
		const char* str = s.c_str();
		unsigned int seed = 131; // 31 131 1313 13131 131313
		unsigned int hash = 0;
		while (*str)
		{
			hash = hash * seed + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}
};
// 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起
template<class V, class HF>
class HashBucket
{
	// ……
private:
	size_t HashFunc(const V& data)
	{
		return HF()(data.first) % _ht.capacity();
	}
};

四、开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间

原文地址:https://blog.csdn.net/weixin_55582891/article/details/134863478 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1733061883583401984.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部