哈希(Hash) - 开散列/闭散列

news2025/7/8 21:42:50

文章目录:

  • 认识哈希
  • 哈希函数
  • 处理冲突的方法
    • 闭散列(开放定址法)
    • 开散列(链地址法)
  • 哈希表闭散列实现
    • 闭散列基本框架
    • 哈希表闭散列插入(insert)
    • 哈希表闭散列删除(erase)
    • 哈希表闭散列查找(find)
  • 哈希表开散列实现
    • 开散列基本框架
    • 哈希表开散列插入(insert)
    • 哈希表开散列删除(erase)
    • 哈希表开散列查找(find)
  • 哈希相关问题思考

认识哈希

🛸顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系,因此查找一个元素时,需要用关键码进行多次的比较。顺序查找时间复杂度为O(N),平衡树中查找元素的时间复制度为O(logN),即取决于树的高度。而理想的搜索方法是可以不经过任何比较,在时间复杂度为O(1)的情况下从表中找到需要的元素。如果构造一种存储结构,该结构可通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么查找元素时就可以直接定位元素的位置,使查找元素的效率大大提高。

❓该结构是如何存储和查找元素的呢?
插入元素: 根据待插入元素的关键码计算出该元素在此存储结构中对应的位置进行插入。
查找元素: 对元素的关键码进行同样的计算,计算出的函数值作为元素的存储位置,在结构中按此位置进行元素的比较,若关键码相等,则查找成功。

这种存储元素的方式即为哈希(散列)方法,哈希方法中使用的关键码转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table),也可以叫做散列表。

🌰举个例子:将以下数据插入哈希表中 {1,5,6,8,9,10},哈希函数设置为 hash(key) = key % capacity ,capacity 为存储元素底层空间的总大小。
其各元素对应的位置如下图所示:
在这里插入图片描述
当我们需要搜索某个元素时,只需要将它的关键码按照对应哈希函数计算其存放位置并判断是否待查找元素即可。但是也出现了一些问题:若多个待插入元素用哈希函数计算出来的值相等,那么就存在冲突问题了,那么应该怎么进行解决呢?

哈希冲突:
不同元素的关键码通过哈希函数计算出相同的哈希地址,这称为哈希冲突(哈希碰撞)。
在实际运用中,冲突只能尽量减小,而不能完全避免。

哈希函数

哈希函数(Hash Function),又叫做散列函数、散列算法。哈希函数能够将任意长度的输入值转换成固定长度的值输出,该值称为散列值,输出值通常为字母与数字组合。

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

哈希函数的设计原则:

  • 哈希函数应该比较简单
  • 哈希函数计算出来的地址应能够均匀的分布在所给的空间
  • 哈希函数的定义域必须包括需要存储的全部关键码,若散列表允许有 n 个地址时,哈希函数计算出的值应该在 0 ~ n-1 之间。

以下是常见的哈希函数:

下列哈希函数中第一种和第二种较为常用,其它的可作为了解。哈希函数的设计方法有很多,哈希函数设计的越精妙,产生的哈希冲突会降低,但是哈希冲突是无法完全避免的。因此,我们只能设计更精妙的方法去降低哈希冲突的概率。

1、直接定址法

取关键字的某个线性函数为散列地址:Hash(key) = A*key + B
优点:简单,且计算出的值在空间中分布比较均匀。
缺点:需要预先知道关键字的分布情况,使用场景较局限,通常要求数据是整数且范围集中。

使用场景:适用于整数且数据范围比较集中的情况。


2、除留余数法
若散列表中允许的地址数为 n ,取一个不大于 n ,且最接近或者等于 n 的质数 p 作为除数,按照哈希函数:Hash(key) = key % p (p<=n),将关键码转换为哈希地址。
优点:简单且使用场景较广泛。
缺点:存在一定的哈希冲突,若哈希冲突较多而无法解决,将会导致效率大大的下降。


3、平方取中法
将数据中的关键字进行平方运算,抽取运算结果中间部分的值作为哈希地址。如:若关键字为1234 ,1234^2 = 1522756,因此可取中间的三位数 227 用来作为哈希地址。

使用场景:关键码位数不是很大,不知道关键码的分布情况。


4、折叠法
折叠法是将关键字分割成位数相等的几部分(最后一部分可以短一些),然后将这几部分叠加求和,并按照散列表表长,取后几位作为哈希地址。

使用场景:预先不知道关键字的分布,适合关键字位数比较多的情况。
在这里插入图片描述


5、随机数法
选择一个随机函数,取关键字的随机函数值作为哈希地址,即 Hash(key) = random(key),其中 random 为随机数函数。

使用场景:适用于关键字长度不等


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

使用场景:关键字位数比较大的情况,事先知道关键字的分布且关键字的若干位分布较均匀的情况。
在这里插入图片描述

处理冲突的方法

在散列函数的构造过程中,我们尽量使散列地址均匀地分布与整个地址空间,但在实际应用中,冲突只能尽量减小,而不能完全避免。接下来我们要解决的是在哈希冲突发生时,如何有效的解决它。常用的处理冲突的方法有两种:闭散列(开放地址法 - Open Addressing)和 闭散列(链地址法 - Linear Probing)。

闭散列(开放定址法)

闭散列:也叫做开放定址法,当发生哈希冲突时,若哈希表未被填满,说明哈希表中还有空的存储位置,这时就需要将冲突的这个值存在另外一个空位置去,那我们应该怎样寻找那个空位置呢?我们较为常用的有以下两种方法:

1、线性探测

线性探测即从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置即可。它的基本公式是:Hash(key) = (key + d) mod TableSize (d = 1,2,3,4......) .

例如:将序列{10,3,5,7,0,13,17}用除留余数法插入到表长为10的哈希表中。

  • 通过哈希函数获取待插入元素在哈希表中的位置
  • 若该位置中没有元素则直接插入新元素,若该位置中已经有元素发生哈希冲突,则使用线性探测找到下一个空位置,插入新的元素。

序列插入过程如下:
在这里插入图片描述
通过以上插入数据的演示我们可以发现,随着插入数据的增多, 插入的数据产生冲突的概率也增加了。哈希表中的元素越多,查找数据时的效率就越低。因此,引入了负载因子(载荷因子)的概念。

载荷因子 = 表中元素的个数 / 散列表的空间大小
载荷因子越大,产生冲突的可能性就越大;
载荷因子越小,产生冲突的可能性就越小;

❓哈希表什么情况下进行扩容?怎样扩容?

负载因子越大,哈希冲突的概率越高,效率降低。负载因子越小,哈希表冲突的概率越小,但也意味着哈希表中的空间利用率越低,此时很多空间都被浪费了。对于开放定址法,载荷因子是特别重要的因素,一般控制在 0.7 - 0.8 以下,若超过 0.8 则会导致在表中查询数据时的 CPU 缓存不命中(cache missing) ,按照质数曲线上升。因此,一些采用开放定址法的Hash库,如Java的系统限制了负载因子为0.75,若超过此值则采用扩容的机制。

总结:线性探测的实现原理非常简单且易于理解,但是却存在着一些问题,若产生的冲突较多,所有冲突连成一片,则产生数据堆积,继续插入数据时发生踩踏效应(需要多次比较寻找位置),因此导致哈希表的搜索效率降低。

2、二次探测
线性探测的缺陷是产生冲突的数据堆积在一起 ,这与其找下一个空位置的方法有关,因为找空位置的方式是挨着逐个往后查找,因此二次探测为了避免这个问题,找下一个空位置的公式为::Hash(key) = (key + d^2) mod TableSize (d = 1,2,3,4......) .

例如:将序列{1,3,11,12,5,17,7}用除留余数法插入到表长为10的哈希表中。当发生哈希冲突时使用二次探测的方法寻找下一个空位置。

序列插入过程如下:
在这里插入图片描述
研究表明:当表的长度为质数且表的负载因子不超过0.5时,新的表项一定能够插入,而且任意一个位置都不会被探测两次。因此只要表中有一半的空位置,就不会存在表满的问题。在搜索时可以不考虑表满的情况,但是在插入时一般情况下确保负载因子不超多0.7,超出则需要考虑扩容了。

散列表最大的缺陷就是空间利用率较低,这也是哈希的缺陷。

开散列(链地址法)

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

例如:用除留余数法将序列{47,7,29,11,16,92,22,8,3,50,37,89,94,21}插入到表长为11的哈希表中,散列函数为:Hash(key) = key % 11。用分离链接法处理冲突,如下如所示:
在这里插入图片描述
一般情况下,每个结点对应的链表结点都很少,将n个关键码通过某个散列函数,存放在散列表中的m个桶中,平均每一个桶中存储n/m个数据。以搜索平均长度为n/m的链表代替了搜索长度为n的顺序表,搜索效率增加了。

🧩用链地址法处理哈希冲突,需要增加链表指针,增加了存储开销。事实上,由于开放地址法需要确保搜索效率而浪费了大量的空间,而表项所占的空间又比指针大得多,因此使用链地址法相较于开放地址法更加节省空间。开散列的哈希桶,负载因子可以超过1,一般情况下控制在[0.0,1.0]之间

❗桶的数量是一定的,随着元素的不断插入,每个桶中元素的个数不断增多,极端情况下,可能会导致一个桶中链表很长,影响哈希表的性能。因此在一定条件下需要对哈希表进行增容。此时哈希表中的数据会全部重新插入到增容后的哈希表中,此时降低了冲突的概率。

在新版的Java中,为了避免数据冲突太多导致效率低下的情况,当某个哈希桶中的数据超过8个时,就将该桶下的单链表结构改为红黑树结构。而当桶中的数据减小到8个及以下时,又将红黑树结构退回为单链表结构。因此就算冲突的数据很多也解决了效率的问题。

如下图所示:
在这里插入图片描述

哈希表闭散列实现

闭散列基本框架

在闭散列实现的哈希表中,哈希表的每个存储位除了存储数据之外还应该存储一个状态值来标识该位置的状态,其中可用3个状态位(EMPTY(没有存储数据),EXITS(当前位置已存储数据),DELTE(当前位置存在的数据被删除))来标识每个存储位当前的存储情况。

// 哈希表每个空间给个标记
// EMPTY此位置为空, EXITS此位置已有元素, DELETE元素已经删除
enum State{EMPTY,EXITS,DELETE};

❓为什么每个存储位都需要标识自身的状态呢?
例如:我们需要查找数据25,但是在查找数据之前对数据15进行了删除,因此我们在算出25的哈希位置是5之后开始进行对比依次向后进行查找,若找到数据25则判断为存在,若遇到空格还没有找到就停下来,说明哈希表中没有存储此数据。在此案例中,15被删除了,所以查找到下标为6的位置为空则停止查找,就找不到25了。因此我们需要用一个状态去标识每个存储位的实际情况。
在这里插入图片描述
显然,我们不可能用0,1这样的数字标识符去标识状态,因为哈希表中可能存储这样的数据。因此,我们用三个状态(EMPTY,EXITS,DELETE)来标识。当我们在哈希表中查找数据时,若当前位置数据与待查找数据不匹配,且当前位置的状态是EXITS或者DELETE时,都应该继续往后进行查找,若遇到状态为EMPTY则不存在待查找的数据。插入元素时,可将元素插入到状态为EMPTY和DELETE的位置,并将状态改为EXITS。

// 闭散列
namespace CloseHash
{

	// 标识存储位置状态
	enum State
	{
		EMPTY,  
		EXITS,
		DELETE,
	};

	template<class K,class V>
	struct HashDate
	{
		pair<K, V> _kv; // 存储数据的键值对
		State _state;   // 标记状态
	};

	template<class K,class V,class HashFunc>
	class HashTable
	{
	public:

	private:
		vector<HashDate<K, V>> _table; // vector作为底层数据结构
		
		// 为了插入元素时计算当前哈希表的负载因此,因此我们增加此变量
		size_t _n = 0;  // 存储的有效数据个数
	};
}

哈希表闭散列插入(insert)

哈希表中插入数据的步骤如下:

  • 查找哈希表中是否存在此键值对,若存在则不进行插入。
  • 判断是否需要对哈希表的大小进行调整,若第一次插入哈希表大小为0或者负载因子不符合要求都需要调整哈希表大小。
  • 检测待插入元素算出的哈希地址对应的位置中是否已存在元素,不存在则直接插入,若产生哈希冲突则从该位置开始,采用线性探测(二次探测)依次向后寻找一个状态为EMPTY或DELETE的位置,将该元素插入,并设置该位置的状态为EXITS。
  • 更新哈希表中有效元素个数。

哈希表的初始空间大小为0时,直接将其初始化为10(根据具体情况设置初始值),负载因子的大小控制在0.7及以下,若负载因子大于0.7则创建一个空间大小为原始哈希表空间大小2倍的新哈希表。然后遍历原始哈希表,将其中数据插入新的哈希表中,然后交换两个哈希表即可。

❗注意: 将原始哈希表中的数据插入新的哈希表中时需要根据新的哈希表空间大小计算对应的哈希位置,而不是直接将原始哈希表中的数据挪到新哈希表对应的位置中去。

插入代码如下:

bool insert(const pair<K, V>& kv)
{
	// 检测待插入的数据在哈希表中是否已经存在
	if (find(kv.first))
	{
		return false; // 若待插入值已存在,则插入失败
	}

	// 检测负载因子大小,负载因子到0.7以上就需要扩容
	if (_table.size() == 0 || _n * 10 / _table.size() > 7)
	{
		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;

		// 扩容以后,需要重新映射位置到新哈希表中
		// 方法一:
		//vector<HashDate> newTable;
		//newTable.resize(newSize * 2);
		//for (auto& e : _table)
		//{
		//	// 重新计算哈希地址将元素插入新表中,与下面逻辑类似
		//}
		//_table.swap(newTable);

        // 方法二:
		// 用哈希表定义一个对象
		HashTable<K, V, HashFunc> newHT;
		newHT._table.resize(newSize);
		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 = 0;
	while (_table[index]._state == EXITS)
	{
		//index = start + i * i;  // 二次探测
		index = start + i;      // 线性探测
		index %= _table.size(); // 防止下标越界
		++i;
	}
	// 将待插入元素插入对应位置,并将其状态改为EXITS,将哈希表中有效元素个数+1
	_table[index]._kv = kv;
	_table[index]._state = EXITS;
	++_n;

	return true;
}

哈希表闭散列删除(erase)

因为标识了每个存储位置的状态,因此删除元素的时候直接采用伪删除的方式即可,也就是将要删除位置的状态改为DELETE。伪删除也不会影响新的元素插入,因为插入新的元素只需要将该位置元素覆盖即可。

哈希表闭散列删除元素的步骤:

  • 检测待删除的元素在哈希表中是否存在,若不存在则删除失败。
  • 若存在,则将该位置的状态更改为DELETE。
  • 更新哈希表中的有效元素个数。

删除代码如下:

bool erase(const K& key)
{
	// 查找该元素是否在哈希表中存在
	HashDate<K, V>* ret = find(key);
	if (ret == nullptr)
		return false;
	else // 找到该元素
	{
		// 将其状态置为DELETE,并将有效元素个数-1
		ret->_state = DELETE;
		--_n;
		return true;
	}
}

哈希表闭散列查找(find)

哈希表闭散列查找元素的步骤:

  • 判断哈希表大小是否为0,若是,则查找失败。
  • 通过插入元素的哈希函数计算待查找元素的哈希地址。
  • 从计算出的位置开始,按照哈希冲突的解决方法(线性探测 or 二次探测)依次向后进行元素查找,直到查找到该元素,或者是找到一个状态为EMPTY的位置则查找失败,表明该哈希表中没有此元素。

查找代码如下:

HashDate<K, V>* find(const K& key)
{
	// 表的大小为0,则查找失败,返回nullptr
	if (_table.size() == 0)
	{
		return nullptr;
	}

	// 计算待查找元素的哈希地址
	HashFunc hf;
	size_t start = hf(key) % _table.size();
	size_t index = start;
	size_t i = 1; // 初始值设定为1,映射位置查找不到,则直接到下一个位置查找
	
	// 哈希表中存储位置状态不为空,则继续查找
	while (_table[index]._state != EMPTY)
	{
		// 找到待查找元素,并返回它的地址
		if (_table[index]._state == EXITS && _table[index]._kv.first == key)
		{
			return &_table[index];
		}

		// 该位置不是待查找元素,继续按照相应规则向后查找
		//index = start + i * i; // 二次探测
		index = start + i;       // 线性探测
		index %= _table.size();
		++i;
	}
	// 走到存储位置为空的状态,不存在此元素,返回空指针
	return nullptr;
}

在这里插入图片描述

哈希表开散列实现

开散列基本框架

开散列的哈希表中,哈希表的每个位置存储的是一个单链表的头节点,即每个哈希桶存储的数据是一个结点类型,该节点中包含数据域和指针域。开散列的实现也需要判断负载因子的大小,因此需要记录当前开散列中有效元素的个数。

namespace Bucket
{
	template<class K,class V>
	struct HashNode
	{
		HashNode<K, V>* _next; 
		pair<K, V> _kv;

		HashNode(const pair<K, V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};

	template<class K,class V,class HashFunc>
	class HashTable
	{
		// 重定义一下,方便使用
		typedef HashNode<K, V> Node;
	public:
		
	private:
		vector<Node*> _table; // 表的每个元素为一个结点指针
		size_t _n = 0; // 有效数据个数
	};
}

哈希表开散列插入(insert)

开散列中插入数据步骤:

  • 检测哈希表中是否已存在待插入的数据,若存在则插入失败。
  • 根据负载因子来判断是否需要扩容(一般负载因子>=1则扩容)。
  • 按照对应哈希函数计算待插入元素哈希地址头插到哈希表中,表中有效元素个数+1。

注意:在扩容的时候,需要将原哈希表的数据插入到新哈希表中,这里可以通过复用插入函数进行数据的重新插入,但在这个过程中需要创建相同数据的结点插入到新哈希表中,还需要清理原哈希表。可以这样做,但是没有必要。事实上,我们只需要遍历原哈希表的每个哈希地址,通过哈希函数计算每个数据在新哈希表中的对应位置,只需要将该节点取下来接在新的哈希表中即可。省略了创建节点和释放节点的过程。

插入代码如下:

bool insert(const pair<K, V>& kv)
{
	// 检测该值是否存在哈希表中,存在则返回false
	if (find(kv.first))
		return false;

	HashFunc hf;
	// 负载因子到1时进行扩容
	if (_table.size() == _n)
	{
		// 不推荐这样写
		/*size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		HashTable<K, V, HashFunc> newHT;
		newHT._table.resize(newSize,nullptr);

		for (size_t i = 0;i < _table.size();++i)
		{
			Node* cur = _table[i];
			while (cur)
			{
				newHT.insert(cur->_kv);  
				cur = cur->_next;
			}
		}
		newHT._table.swap(_table);*/

		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		vector<Node*> newTable;
		newTable.resize(newSize, nullptr);

		// 遍历取原表中节点,重新算映射到新表中的位置,接到新表中
		for (size_t i = 0;i < _table.size();++i)
		{
			Node* cur = _table[i];
			// 遍历当前哈希地址中的数据
			while (cur)
			{
				// 保存当前需要摘取节点的下一个节点
				Node* next = cur->_next;

				// 计算当前节点在新表中对应的哈希地址并头插到新的哈希表中
				size_t index = hf(cur->_kv.first) % newSize;
				cur->_next = newTable[index];
				newTable[index] = cur;

				cur = next;
			}
			_table[i] = nullptr;
		}
		newTable.swap(_table);
	}

	// 计算待插入节点的哈希地址,将待插入节点头插到对应哈希地址下
	size_t index = hf(kv.first) % _table.size();
	Node* newnode = new Node(kv);
	newnode->_next = _table[index];
	_table[index] = newnode;

	// 更新有效元素个数
	++_n;
	return true;
}

哈希表开散列删除(erase)

开散列中删除数据步骤:

  • 检测哈希表大小是否为0,若是则返回false。
  • 通过对应哈希函数计算出该元素对应的哈希地址,遍历对应的哈希桶,查找待删除结点。
  • 若找到了对应的节点,则将该节点删除,并更新有效元素个数。

删除代码如下:

bool erase(const K& key)
{
	// 检测哈希表大小是否为0
	if (_table.size() == 0)
		return false;

	// 计算待删除元素对应的哈希地址
	HashFunc hf;
	size_t index = hf(key) % _table.size();

	Node* prev = nullptr;
	Node* cur = _table[index];
	while (cur)
	{
		// 找到待删除元素
		if (cur->_kv.first == key)
		{
			// 判断待删除元素是第一个节点还是中间节点
			if (_table[index] == cur)
				_table[index] = cur->_next;
			else
				prev->_next = cur->_next;

			--_n;
			delete cur;
			return true;
		}
		// 向后查找
		prev = cur;
		cur = cur->_next;
	}
	// 没有找到待删除元素
	return false;
}

哈希表开散列查找(find)

开散列中查找数据步骤:

  • 检测哈希表的大小是否为0,如为0则查找失败。
  • 按照哈希函数计算待查找数据的哈希地址。
  • 通过哈希地址找到对应的哈希桶,然后遍历单链表进行查找。

查找代码如下:

Node* find(const K& key)
{
	if (_table.size() == 0)
		return nullptr;

	HashFunc hf;
	size_t index = hf(key) % _table.size();
	Node* cur = _table[index];
	while (cur)
	{
		if (cur->_kv.first == key)
			return cur;
		cur = cur->_next;
	}
	return nullptr;
}

哈希相关问题思考

哈希函数计算哈希地址时只能用整数去计算,其它类型应该怎么解决呢?

哈希函数采用除留余数法,被模的key必须要为整数才可以处理,此处提供将key转化为整形的方法去解决此问题。具体应该怎么转化可以看看这篇文章:各种字符串哈希函数

例如:

// 特化
template<>
struct Hash<string>
{
	// 字符串转成对应的一个整形值,因为整形才能取模算映射位置
	// 尽量让字符串不同,转出的整形值尽量不同
	size_t operator()(const string& s)
	{
		// "abc" "cba"
		size_t value = 0;
		for (auto ch : s)
		{
			value += ch;
			// BKDL Hash
			value *= 131;
		}
		return value;
	}
};

❓哈希表的大小为什么建议是素数?

对于哈希表的大小最好为素数这个问题目前是存在争议的。若对其原因感兴趣可以去网上找来看看,这里就不解释了,因为也解释不准确。

那么我们应该如何快速获取一个类似两倍关系的素数呢?哈希增容两倍时哈希表的大小就不再是素数了,找到下一个素数也非常不容易,因此我们可以提前准备一个素数表,需要的时候直接从中获取即可。如下所示:以下表中的素数都以接近2倍的速度增长。

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

增容的时候,直接获取下一个素数即可。

newTable.resize(GetNextPrime(_table.size()));

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/6917.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

深度学习模型部署全流程-模型部署

往期回顾&#xff1a;模型训练 文章目录前言模型部署全流程1.推理框架2.onnx模型3.模型转换4.代码实现5.完整代码小结前言 在上一篇文章中详细讲述了模型训练的流程&#xff0c;这篇文章主要介绍模型部署的流程。模型部署通常指通过C/C语言能够把python框架训练好的模型跑起来…

【ROS】机械人开发一--树莓派安装ubuntu18.04

前言&#xff1a;安装了一天的树莓派系统&#xff0c;遇到了很多坑&#xff0c;这里将教程详细分享一下&#xff0c;方便大家快速的安装系统。 目录一、操作环境硬件软件二、资源下载链接三、具体步骤烧入修改镜像文件问题修改重启时间PC端使用xshell远程连接修改软件源安装ubu…

嵌入式软件调试(Debug)方法

嵌入式软件调试&#xff08;Debug&#xff09;方法1 问题定位和分析方法1.1 二分定位法1.2 数据流方法1.3 隔离法1.4 汇编法1.5 ABA法1.6 版本回溯确认法1.7 调试IO法2 调试注意事项3 典型问题类型1 问题定位和分析方法 1.1 二分定位法 方法阐述&#xff1a; 在任务中或者可能…

Redis介绍与下载

初识Redis Redis介绍 由Salvatore Sanfilippo写的key-value存储系统&#xff0c;是跨平台的非关系型数据库 Redis通常被称之为数据结构服务器&#xff0c;因为值(value)可以是字符串、哈希、列表、集合和有序集合等类型 Redis是完全开源的遵守BSD协议&#xff0c;是一个高性能的…

看着别人月入过万,30岁想转入做软件测试,有什么难度?

我见过很多30岁转行软件测试成功的&#xff0c;也见过软件测试转行失败的。 说实话&#xff0c;30岁转行需要付出比一般人更加多的努力。 并且每一步的路都不能走偏。 30岁了&#xff0c;转行肯定不像才毕业的小年轻那么容易&#xff0c;毕竟你转行要跟社会上已经从事过几年的…

Android移动应用开发之使用room实现数据库的增删改查

文章目录前言核心代码前言 我们直接开门见山&#xff0c;展示一下效果&#xff1a; 数据库的插入和查询&#xff1a; 数据库的修改和查询&#xff1a; 可以看到id为23的数据发生了修改。 删除一条数据&#xff1a; 可以看到id为23的数据被删除了 删除全部数据&#xff1…

Sedex验厂有证书吗?

【Sedex验厂有证书吗&#xff1f;】 SEDEX 是一个全球性的会员制组织&#xff0c;旨在帮助企业在负责任商业中去繁存简&#xff0c;携手共进。买家、供应商和审计员可以在平台上快速轻松地储存、共享和报告信息。 SMETA&#xff08;Sedex Members Ethical Trade Audit&#xff…

日本知名汽车零部件公司巡礼系列之株式会社111

株式会社111 业务内容&#xff1a; . 在所有领域的零件缴纳各种都有相应的实际业绩 &#xff08;例&#xff09;OA器械、光学器械、汽车其他运送器械、医疗器械、各种制造装置零件、机器人相关零件、能源相关零件、航空相关零件等 广泛应对各种材料产品 铁、铝、不锈钢、合…

【FLASH存储器系列八】ONFI数据接口详述之一

目录 1.1 数据接口类型概览 1.2 信号功能分配 1.3 接口模式切换 1.1 数据接口类型概览 ONFI目前支持5中不同的数据接口类型&#xff1a;SDR&#xff0c;NV-DDR&#xff0c;NV-DDR2、NV-DDR3和NV-LPDDR4。SDR是传统的NAND接口&#xff0c;使用RE_n锁存读数据&#xff0c;WE_n锁…

MSP430F5529库函数——模数转换模块(ADC12)软件触发

需提前观看&#xff1a;MSP430F5529库函数学习——串口 目录 代码 ADC初始化部分 引脚复位 ADC12_A_init&#xff08;&#xff09; 函数声明 baseAddress sampleHoldSignalSourceSelect clockSourceSelec clockSourceDivider ADC12_A_enable&#xff08;&#xff09;…

有关javascript中事件对象e

一、简单认识e 事件对象e&#xff0c;是event的简称。当一个事件被触发时候&#xff0c;这个事件的有关数据都会被存储在一个事件对象e里面&#xff0c;这个对象e有许多固定方法提供给我们查看里面各种数据。 二、关于e对象的常用属性介绍 1. e.eventPhase查看事件触发所处的阶…

MySQL索引原理笔记

注意&#xff1a;本博客为个人学习记录&#xff0c;不保证正确性&#xff0c;仅供参考指正 MySQL索引原理以及SQL优化 文章目录MySQL索引原理以及SQL优化索引与约束覆盖索引最左匹配规则索引下推&#xff08;面试重点&#xff09;索引存储索引失效如何解决sql比较慢的问题索引…

【JavaWeb】JSP(172-190)

172.Jsp-什么是jsp&#xff0c;以及它有什么作用 jsp 的全换是 java server pages。Java 的服务器页面。 jsp 的主要作用是代替 Servlet 程序回传 html 页面的数据。 因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。 Servlet 回传 htm…

大白话讲解MySQL 索引,页分裂,行溢出,事务

目录 一、索引 索引是什么&#xff0c;页分裂 页的结构 mysql怎么查询数据 二、页合并 三、行溢出 四、事务 事务四大特性 1、原子性 2、一致性 3、隔离性 4、持久性 事务隔离级别 隔离级别导致的问题 隔离级别与锁的关系 锁与快照读、当前读的关系 RR快照读与…

网页信息采集-网页数据采集方法

随着社会不停的发展。人们也是越来越离不开互联网&#xff0c;今天小编就给大家盘点一下免费的网页信息采集&#xff0c;只需要点几下鼠标就能轻松爬取数据&#xff0c;不管是导出excel还是自动发布到网站都支持。详细参考图片一、二、三、四&#xff01; 企业人员 通过爬取动…

[附源码]计算机毕业设计JAVA创意众筹网站

[附源码]计算机毕业设计JAVA创意众筹网站 项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis M…

JavaScript历史上的今天是星期几

前言 &#x1f44f;这个案例有很多点是我之前不知道的&#xff08;因为是小白&#xff09;&#xff0c;所以很值得学习&#xff0c; ✍编程不是打字机&#xff0c;⭐争取明白每个细节&#xff0c;并努力做的更好 步骤 1.html布局&#xff0c;一个下拉菜单&#xff08;如图&…

独家巨献!阿里专家兼Github贡献者业“大师级Dubbo实战笔记”入门到成神

Apache Dubbo是一款RPC服务开发框架&#xff0c;那何为RPC呢&#xff1f;全称为Remote Procedure Call&#xff0c;翻译过来就是远程过程调用。 使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力&#xff0c; 利用 Dubbo 提供的丰富服务治理特性&#xff0c;可…

ZYNQ使用AXI4-HP接口总线读取DDR中的数据

一、前言 最近笔者在做项目的时候需要使用zynq中的AXI4-HP总线在PL端读取DDR中的数据这种功能&#xff0c;但是网上很多历程对于这方面只是创建了一个官方提供的IP核用于测试&#xff0c;并且每次写入和读取的长度为4K字节。所以为了满足我自己的项目需求&#xff0c;笔者将官…

电脑桌面图标不见了怎么回事?正确的找回图标的2个方案

最近遇到很多用户朋友说自己的电脑桌面图标不见了&#xff0c;觉得很奇怪。用户以为是系统原因造成的。电脑桌面图标不见了怎么回事&#xff1f;图标删除了怎么办&#xff1f;这篇文章就给大家分享如何找回电脑桌面消失的图标&#xff0c;一起来看看吧&#xff01; 一、找回电脑…