哈希介绍及哈希桶的实现

最新推荐文章于 2024-04-25 18:43:56 发布

饱和泽

最新推荐文章于 2024-04-25 18:43:56 发布

阅读量464

点赞数

分类专栏： C++ 文章标签：哈希算法算法散列表数据结构

本文链接：https://blog.csdn.net/m0_69597277/article/details/130504809

版权

C++ 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

哈希介绍及哈希桶的实现

文章目录：

一、哈希结构

1 何为哈希
2 哈希函数
3 哈希冲突
3.1 闭散列：线性探测 & 二次探测
3.2 开散列

二、哈希桶实现

线性探测哈希表实现
开散列哈希桶实现

前言

我们知道，关联式容器里面以红黑树作为底层结构的map、set系列容器在元素的查询效率上可达到O( $log_2N$ ) ，即最差情况下也只需要比较红黑树的高度次，但当树中节点非常多时，其查询效率也不是很理想。
最好的查询是，进行很少的比较次数就能够将元素找到。
以哈希桶为底层结构的关联式容器unordered_set、unordered_map等在元素的查找上面其效率可达到O(1)。
实际上，哈希是采用空间换取时间的策略来提高元素查找的效率的。

编译环境：vs2013

一、哈希结构

1 何为哈希

在顺序结构和平衡树中，元素关键码与其存储位置之间是没有对应的关系的，故当我们在查找一个元素的时候是进行多次的比较来找到元素所处的位置。
顺序查找中时间复杂度为O(N)，平衡树中为树的高度，即O( $log_2 N$ )，搜索的效率取决于搜索过程中元素的比较次数。

思考：如果可以通过某种函数将元素关键码值和其存储位置之间建立一个一一映射的关系，那查找元素就可以不用多次的进行元素间的比较了。
哈希便是采用这一思想来进行元素关键码的数据存储。

建立的函数称为哈希函数。

哈希（散列）函数：将元素关键码值和其存储位置之间建立的一一映射的关系函数。
哈希（散列）方法：元素关键码值不经过任何的比较，采用哈希函数直接从存储表中进行元素的获取的方法。
哈希（散列）结构：通过哈希函数构造的一个存储结构，构造出来的结构成为哈
希表或散列表。
当向此结构中：
插入函数：根据待插入元素的关键码，带入哈希函数计算出此元素的存储位置
并将此元素存储到该位置上去。
查找元素：通过哈希函数计算待查找元素的存储位置，在存储结构中按此位置
取元素进行比较，若相等，则查找成功。

在这里插入图片描述
这时我们可以看到：若现在要存储元素关键码为54的元素，其通过哈希函数计算出来的元素存储位置为4号位置，显而易见，4号位置此时已经存储元素34了，那这种情况又该如何呢？

此时这种情况，我们称为哈希冲突。

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

哈希冲突又该如何解决？
哈希冲突出现的一个原因可能是哈希函数的设计不够合理导致。所以设计一个合理的哈希函数很大程度上能够减少哈希冲突的产生。

2 哈希函数

2.1 设计出来的哈希函数原则上应：

①哈希函数定义域必须包含所有待存储的元素关键码，若哈希表中有m个地址时，其值域必须在0~m-1之间。
②哈希函数计算出来的地址要均匀的分布在整个空间中。
③哈希函数应避免复杂化。

2.2 常见的设计的哈希函数

直接定址法
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
平方取中法
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；
再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址。
使用场景：不知道关键字的分布，而位数又不是很大的情况。
折叠法
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
使用场景：事先不需要知道关键字的分布，适合关键字位数比较多的情况。
随机数法
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
使用场景：应用于关键字长度不等时采用此法。
数学分析法
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
使用场景：处理关键值比较大的情况和事先知道关键字的分布且关键字的若干位分布较均匀的情况。

在使用中：通常使用直接定址法和除留余数法。
注意：哈希函数设计越合理，产生哈希冲突发生概率越小，而哈希冲突是不可避免的。

3 哈希冲突

哈希冲突是无法避免的，哈希函数设计上只是尽可能的减少哈希冲突，并未真正地解决哈希冲突。
解决哈希冲突的方式有：开散列和闭散列。

3.1 闭散列（开放定址法）
上述产生哈希冲突的原因无非就是哈希函数计算出来的哈希地址已存储元素，但是还有其他的位置是空的。
闭散列原理：从发生哈希冲突的位置开始，往后找第一个空位置来作为其存储位。
根据找的方式的不同，又可分为线性探测和二次探测。
（1）线性探测
方式：从发生冲突的位置开始，依次往后探测，直到找到空位置。

那我们如何知道位置上到底有没有元素呢？

故需对哈希表中位置进行标记，若此位置有元素则标记 EX(exist)，没有则标记 EM(empty)。

① 元素的插入

哈希函数计算待插入元素的哈希地址。
未产生哈希冲突，则直接进行元素插入，将EM状态改为EX状态；相反，则从产生冲突位置找下一个空位置来进行元素的插入，同样将EM状态改为EX状态。

②元素的删除
在进行元素的删除时，不可直接进行元素的删除，若直接删除会影响其他元素的查找。

如：删除元素34，如果直接把34删除掉，将存储34的位置的标志修改为EM（empty）。若要查找元素54，先通过哈希函数计算54的存储位置，而现在的存储位置显示EM，表示没有元素，结果就会返回未找到元素54。
故：需增加一个标志位，将元素删除后，将该位置处标志修改为DEL（delete），表
明此位置原来有元素但已被删除了。

元素查找删除元素是否在哈希表中。
元素存在将元素所在位置标志修改为DEL状态。

③元素的查找

哈希函数计算待查找元素的哈希地址。
若此哈希地址状态为EM，表明此位置没有存储元素，则带查找元素一定不存在表中；若不为EM，则查看此位置元素是否为待查找元素，如果是则找到，不是的话说明此位置发生过哈希冲突，线性探测从此位置处开始依次往后查找，当走到地址末尾时，从头再开始进行探测。

哈希表中元素越多，则冲突产生概率越大，当哈希表中元素到达一定程度（一定程度用哈希载荷因子来衡量）后，发生哈希冲突的概率就会升高。此时哈希表便需要进行扩容。

定义：哈希载荷因子（负载因子）= $\frac{有效元素个数}{哈希表大小}$

对于线性探测来说：负载因子应控制在70%左右。

线性探测解决哈希冲突：

优点：处理方式简单
缺点：容易导致数据的堆积【一次的冲突可能会引起一片数据的冲突】
注意：在进行线性探测的时候，当探测到末尾的时候，这时需从头开始往后继续
进行探测。

为解决线性探测的数据堆积问题，又引入了二次探测。

（2）二次探测
方式：第一次计算哈希地址为 $H_0$ ，第i次探测的哈希地址为： $H (i)$ = $H_0$ $\pm$ $i^2$

即：
哈希函数计算待插入元素的哈希地址值记为 $H_0$ ，若此地址产生哈希冲突，取i=1，计算 $H (i)$ = $H_0$ $\pm$ $i^2$ 探测 $H (1)$ 地址是否发生冲突，未产生冲突则在将元素存储到此地址，产生冲突则继续第二次的探测，依次进行下去，直到找到没有冲突的地址。

其实线性探测和二次探测思想都是找一个空位置来存储产生冲突的元素，不同的是，线性探测是从产生冲突位置依次往后找下一个空位置；二次探测是利用公式来寻找下一个空位置。

二次探测负载因子应控制在60%左右

二次探测解决哈希冲突：

优点：有效解决线性探测数据堆积问题
缺点：若表中空位置较少，需探测多次，其探测次数增加

3.2 开散列（链地址法）
开散列原理：首先对元素关键码集合用哈希函数计算哈希地址，具有相同地址的元素关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在产生冲突插入节点时，我们采用头插法进行元素的插入。
在这里插入图片描述

二、哈希桶的实现

1.闭散列

1.1 线性探测的扩容
哈希表中元素越多，产生冲突的概率越大，前文我们说过线性探测的载荷因子应在70%左右为宜。
故当载荷因子达到0.7时，我们对哈希表进行扩容。

//线性探测哈希表扩容
void _CheckCapacity()
	{
		//当载荷因子达到0.7时，便进行扩容处理
		if (_size * 10 / _table.capacity() >= 7)
		{
			HashTable<K,V> newHT(GetNextPrime(_table.capacity()));
			for (size_t i = 0; i < _table.capacity(); ++i)
			{
				if (_table[i]._state == EX)
					newHT.Insert(_table[i]._val);
			}
			Swap(newHT);
		}
	}

1.2 线性探测简单实现：

#pragma once 
#include<iostream>
#include<vector>
#include<string>
#include<assert.h>

//数据状态
enum State
{
	EM, //空
	EX, //存在
	DEL //删除
};
//表中元素唯一
template<class K,class V>
class HashTable
{
	struct Elem
	{
		pair<K, V> _val;
		State _state;
	};
public:
	HashTable(size_t capacity = 10)
		:_table(capacity)
		, _size(0)
	{
		for (size_t i = 0; i < capacity; ++i)
		{
			_table[i]._state = EM;
		}
	}
	//插入元素
	bool Insert(const pair<K,V>& data)
	{
		//1.检测哈希表空间是否足够
		_CheckCapacity();
		//2.哈希函数计算哈希地址
		size_t hashAddr = HashFunc(data.first);
		//3.找下一个空位置来进行插入
		while (_table[hashAddr]._state != EM)
		{
			if (_table[hashAddr]._state == EX && _table[hashAddr]._val.first == data.first)
				return false;
			hashAddr++;
			//找空位置走到表末尾后得从头开始进行空位置的查找
			if (hashAddr == _table.capacity())
				hashAddr = 0;
		}
		//4.找到空位置，元素插入
		_table[hashAddr]._state = EX;
		_table[hashAddr]._val = data;
		_size++;
		return true;
	}
	//查找元素
	int Find(const K& data)
	{
		//1.计算元素哈希地址
		size_t hashAddr = HashFunc(data);
		while (_table[hashAddr]._state != EM)
		{
			if (_table[hashAddr]._state == EX && _table[hashAddr]._val.first == data)
				return hashAddr;
			hashAddr++;
		}
		return -1;
	}
	//删除元素
	bool Erase(const K& data)
	{
		int index = Find(data);
		if (index !=-1)
		{
			_table[index]._state = DEL;
			_size--;
			return true;
		}
		return false;
	}
	size_t Size()
	{
		return _size;
	}
	void Swap(HashTable<K,V>& ht)
	{
		_table.swap(ht._table);
		std::swap(_size, ht._size);
	}
private:
	void _CheckCapacity()
	{
		//当载荷因子达到0.7时，便进行扩容处理
		if (_size * 10 / _table.capacity() >= 7)
		{
			HashTable<K,V> newHT(GetNextPrime(_table.capacity()));
			for (size_t i = 0; i < _table.capacity(); ++i)
			{
				if (_table[i]._state == EX)
					newHT.Insert(_table[i]._val);
			}
			Swap(newHT);
		}
	}
	size_t HashFunc(const K& data)
	{
		return data%_table.capacity();
	}
private:
	vector<Elem> _table;//哈希表中存储哈希节点
	size_t _size;   //哈希表中有效元素个数
};
//线性探测闭散列测试函数
void TestHashTable()
{
	HashTable<int,int> ht;
	ht.Insert(make_pair(1, 1));
	ht.Insert(make_pair(2, 1));
	ht.Insert(make_pair(5, 3));
	ht.Insert(make_pair(7, 2));
	ht.Insert(make_pair(3, 1));
	//查找2是否在哈希表中
	if (ht.Find(2)!=-1)
	{
		cout << "2 is in the HashTable." << endl;
	}
	else
	{
		cout << "2 is not in the HashTable." << endl;
	}
	cout << "元素个数为：" << ht.Size() << endl;
	//删除2后再查找2是否在哈希表中
	if (ht.Erase(2))
	{
		cout << "删除2成功." << endl;
		if (ht.Find(2) !=-1)
		{
			cout << "删除后找到" << endl;
		}
		else
		{
			cout << "删除2后未找到" << endl;
		}
	}
	else
	{
		cout << "删除2失败." << endl;
	}
	cout << "元素个数为：" << ht.Size() << endl;
}

在这里插入图片描述

2.开散列

2.1 开散列的扩容
桶的个数是一定的，随着元素的不断插入，每个桶中的元素逐渐增多，极端情况下，可能导致某个节点中链表节点很多，从而影响哈希表的性能。
开散列的最好情况为：每个哈希桶中刚好有一个节点，再继续插入元素时，每次都会产生哈希冲突，所以当有效元素个数等于桶的个数时，可对哈希桶扩容。扩容时，按照2倍关系进行扩容。

//空间检测扩容函数
void CheckCapacity()
	{
		//如果表中有效元素等于空间容量，进行空间2倍数扩容
		if (_size == _table.capacity())
		{
		    //两倍方式来进行元素扩容
			HashBucket<T> newHT(_size * 2);
			//将旧桶中元素往新桶中进行插入（不可直接搬移，因为扩容哈希函数也改变了）
			for (size_t i = 0; i < _table.capacity(); ++i)
			{
				Node* cur = _table[i];
				//将i号桶对应的链表中每个节点插入到新桶中去
				while (cur)
				{
					//1.将cur从桶上取出来
					_table[i] = cur->_next;
					//2.将cur插入到新桶中去，先计算cur在新桶中的哈希地址再进行插入
					size_t newBucketNo = newHT.HashFunc(cur->_data);
					cur->_next = newHT._table[newBucketNo];
					newHT._table[newBucketNo] = cur;
					newHT._size++;
					//3.从_table[i]中取下一个节点
					cur = _table[i];
					_size--;
				}
			}
			this->Swap(newHT);
		}
	}

2.2 开散列实现

#pragma once 
#include<iostream>
#include<vector>
#include<string>
#include<assert.h>
using namespace std;
template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* _next;

	HashNode(const T& data = T())
		:_data(data)
		,_next(nullptr)
	{}
};

template<class T>
class HashBucket
{
public:
	typedef HashNode<T> Node;
	
	HashBucket(size_t capacity = 10)
		:_table(capacity)
		, _size(0)
	{}
	~HashBucket()
	{
		Clear();
	}
	//哈希桶中元素唯一
	//元素插入
	bool InsertUnique(const T& data)
	{
		//首先检测一下空间是否需要扩容
		CheckCapacity();
		
		//1.计算哈希地址（即桶号）
		size_t bucketNo = HashFunc(data);
		//2.确保桶中元素唯一，若桶中已有元素data则错误返回，没有的话插入
		Node* cur = _table[bucketNo];
		while (cur)
		{
			if (data == cur->_data)
				return false;
			cur = cur->_next;
		}
		//3.进行新节点的插入
		cur = new Node(data);
		cur->_next = _table[bucketNo];
		_table[bucketNo] = cur;
		++_size;
		return true;
	}
	//元素删除
	size_t EraseUnique(const T& data)
	{
		//1.计算哈希地址（即桶号）
		size_t bucketNo = HashFunc(data);
		//2.在此桶中找到元素进行删除
		Node* cur = _table[bucketNo];
		Node* prev = nullptr;
		while (cur)
		{
			if (data == cur->_data)
			{
				if (cur == _table[bucketNo])
				{
					//删除元素为桶中首节点
					_table[bucketNo] = cur->_next;
				}
				else
				{
					prev -> _next = cur->_next;
				}
				delete cur;
				--_size;
				return 1;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return 0;
	}
	//哈希桶中元素不唯一
	//元素插入
	bool InsertEqual(const T& data)
	{
		//首先检测一下空间是否需要扩容
		CheckCapacity();

		//1.计算哈希地址（即桶号）
		size_t bucketNo = HashFunc(data);

		//2.直接进行新节点的插入
		Node* cur = new Node(data);
		cur->_next = _table[bucketNo];
		_table[bucketNo] = cur;
		++_size;
		return true;
	}
	//元素删除(返回值为删除元素个数)
	size_t EraseEqual(const T& data)
	{
		//1.计算哈希地址（即桶号）
		size_t bucketNo = HashFunc(data);
		size_t oldsize = _size;
		//2.在此桶中找到值为data的元素全部进行删除
		Node* cur = _table[bucketNo];
		Node* prev = nullptr;
		while (cur)
		{
			if (data == cur->_data)
			{
				if (prev==nullptr)
				{
					//删除元素为桶中首节点
					_table[bucketNo] = cur->_next;
					delete cur;
					--_size;
					cur = _table[bucketNo];
				}
				else
				{
					prev = > _next = cur->_next;
					delete cur;
					--_size;
					cur = prev->_next;
				}
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return oldsize - _size;
	}
	//计算桶的个数
	size_t BucketCount()const
	{
		return _table.capacity();
	}
	//计算某个桶中的元素个数
	size_t BucketSize(size_t bucketNo)const
	{
		assert(bucketNo < BucketCount());
		Node* cur = _table[bucketNo];
		size_t size = 0;
		while (cur)
		{
			size++;
			cur = cur->_next;
		}
		return size;
	}
	//计算某个元素所在的桶号
	size_t BucketNo(const T& data)
	{
		return HashFunc(data);
	}
	//查找元素是否存在在桶中
	bool Find(const T& data)
	{
		//1.计算元素所在的桶号
		size_t bucketNo = HashFunc(data);
		//2.检测元素是否存在
		Node* cur = _table[bucketNo];
		while (cur)
		{
			if (cur->_data == data)
				return true;
			cur = cur->_next;
		}
		return false;
	}
	//表中有效元素个数
	size_t Size()const
	{
		return _size;
	}
	void Clear()
	{
		for (size_t i = 0; i < _table.capacity(); ++i)
		{
			Node* cur = _table[i];//获取桶中首节点
			while (cur)
			{
				_table[i] = cur->_next;
				delete cur;
				cur = _table[i];
			}
		}
		_size = 0;
	}
	void Swap(HashBucket<T>& ht)
	{
		_table.swap(ht._table);
		std::swap(_size, ht._size);
	}
	void PrintHash()const
	{
		for (size_t i = 0; i < _table.capacity(); ++i)
		{
			cout << "table[" << i << "]:";
			Node* cur = _table[i];
			while (cur)
			{
				cout << cur->_data << "----->";
				cur = cur->_next;
			}
			cout << "NULL" << endl;
		}
		cout << endl;
	}
private:
	//哈希函数(除留余数法)
	size_t HashFunc(const T& data)const
	{
		return data % _table.capacity();
	}
private:
	vector<Node*> _table;//哈希表中存储哈希节点
	size_t _size;        
};
//测试函数
void TestHashBucket1()
{
	HashBucket<int> ht;
	ht.InsertUnique(1);
	ht.InsertUnique(2);
	ht.InsertUnique(3);
	ht.InsertUnique(4);
	ht.InsertUnique(11);
	ht.InsertUnique(12);
	ht.InsertUnique(13);
	ht.InsertUnique(14);
	ht.InsertUnique(44);
	ht.InsertUnique(54);
	cout << "size=" << ht.Size() << endl;
	ht.PrintHash();

	size_t i=ht.EraseUnique(44);
	if (i)
	{
		cout << "44 is not in the bucket." << endl;
	}
	else
	{
		cout << "44 is in the bucket." << endl;
	}
	cout << "size=" << ht.Size() << endl;

	size_t bucketNo = ht.BucketNo(1);
	cout << "1所在的桶号为：" << bucketNo << endl;
	
	ht.Clear();
	cout << "size=" << ht.Size() << endl;
	cout << "桶的个数为：" << ht.BucketCount() << endl;
}

在这里插入图片描述
以上我们的开散列式的哈希桶实现中存储数据为整型(int)，在实现的时候我们哈希函数采用的是除留余数法。而我们知道只有整型数据才可以进行取模的运算，那我们的哈希桶岂不是只能存储int类型的数据了？

前文我们介绍了除留余数法，和哈希函数设计越精妙，就会很大程度上降低哈希冲突的产生。

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

基于上述的实现，我们提出几个问题：
1.在该哈希函数设计中，我们最好取一个最接近或等于m的质数p作为除数，而在空间扩容的时候我们采用2倍的关系进行扩容，那扩容时，我们如何保证找到接近两倍关系的素数呢？
2.我们在实现的时候，测试的数据为整数，整数可以直接进行取模的运算，那当数据data不是整型(int)时，比如字符串类型(string)，而string类型数据并不可以直接进行数据的取模运算，该如何解决呢？
3.当有效元素个数等于桶个数时，我们进行空间的扩容，若在扩容之前，哈希桶中某条链却很长，那又该如何呢？

Q1：在扩容中，如何找到一个接近两倍关系的素数中，这种素数数据实际上还是挺少的，所以我们可以建立一个表，将一定数量的素数存储起来，在需要扩容时，在表中去找相应的数据即可。

//获取下一个素数
size_t GetNextPrime(size_t prime)
{
	const int PRIMECOUNT = 28;
	static const size_t primeList[PRIMECOUNT] =
	{
		53ul, 97ul, 193ul, 389ul, 769ul,
		1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
		49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
		1572869ul, 3145739ul, 6291469ul, 12582917ul,
		25165843ul,
		50331653ul, 100663319ul, 201326611ul, 402653189ul,
		805306457ul,
		1610612741ul, 3221225473ul, 4294967291ul
	};
	size_t i = 0;
	for (; i < PRIMECOUNT; ++i)
	{
		if (primeList[i] > prime)
			return primeList[i];
	}
	return primeList[i];
}

Q2：当数据不是整型时，我们可以在模板参数中增加一个模板参数，表示将哈希桶中存储的数据转换为整型。

template<class T, class TtoInt>//增加TtoInt，将存储数据转换为int型

//数据转换，处理T是整型家族的类型数据：char/short/int/long/long long
template<class T>
class TtoIntDef
{
public:
	size_t operator()(const T& data)
	{
		return data;
	}
};

//数据转换，处理T为string类型的数据，字符串哈希算法来进行处理
class StrtoInt
{
public:
	size_t operator()(const string& s)
	{
		const char* str = s.c_str();
		unsigned int seed = 131;
		unsigned int hash = 0;
		while(*str)
		{
			hash = hash*send + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}
};

当然，此类的string转换成int的字符串哈希算法还有很多。详见可参考：http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html

//存储string类型的测试函数
void TestHashBucket2()
{
	HashBucket<string, StrtoInt> ht;
	ht.InsertUnique("chinese");
	ht.InsertUnique("math");
	ht.InsertUnique("science");
	ht.InsertUnique("art");

	cout << "size=" << ht.Size() << endl;
	ht.PrintHash();
	//删除"chinese"
	size_t i = ht.EraseUnique("chinese");
	if (i)
	{
		cout << "chinese is not in the bucket." << endl;
	}
	else
	{
		cout << "chinese is in the bucket." << endl;
	}
	cout << "size=" << ht.Size() << endl;

	size_t bucketNo = ht.BucketNo("art");
	cout << "art所在的桶号为：" << bucketNo << endl;
}

在这里插入图片描述

Q3：扩容时机为达到之前哈希桶中某条链却很长，这时候我们可以考虑将链表转换为红黑树。插入操作时，当某一链表中个数超过8，那我们就考虑将链表转化为红黑树来存储元素；当删除的时候，节点个数小于6的时，又将红黑树转化为链表。

总结

哈希桶就实现好了，即unordered_set、unordered_map的底层结构我们就大致实现好了，当然，远不止如此，还有很多的细节得需要添加，如迭代器等，之后我们就可以简单模拟实现一下unordered_set、unordered_map啦！

饱和泽

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
哈希介绍及哈希桶的实现

我们知道，关联式容器里面以红黑树作为底层结构的map、set系列容器在元素的查询效率上可达到O(log2Nlog_2Nlog2N) ，即最差情况下也只需要比较红黑树的高度次，但当树中节点非常多时，其查询效率也不是很理想。最好的查询是，进行很少的比较次数就能够将元素找到。以哈希桶为底层结构的关联式容器unordered_set、unordered_map等在元素的查找上面其效率可达到O(1)。实际上，哈希是采用空间换取时间的策略来提高元素查找的效率的。
复制链接

扫一扫