哈希表(C++实现)

news2024/12/24 8:23:42

文章目录

  • 写在前面
  • 1. 哈希概念
  • 2. 哈希冲突
  • 3. 哈希函数
  • 4.哈希冲突解决
    • 4.1 闭散列
      • 4.1.1 线性探测
      • 4.1.2 采用线性探测的方式解决哈希冲突实现哈希表
      • 4.1.3 二次探测
    • 4.2 开散列
      • 4.2.2 采用链地址法的方式解决哈希冲突实现哈希表

写在前面

在我们之前实现的所有数据结构中(比如：顺序结构以及平衡树中)，要存储的元素与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过多次的比较。如顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。
而我们理想的一种搜索方法为：可以不经过任何比较，一次直接从表中得到要搜索的元素。
下面我们来详细介绍一下这种方法：哈希(散列)方法。

1. 哈希概念

哈希(Hash):是一种通过特定函数（哈希函数，hash function）将数据映射到固定大小的存储空间的方法。其核心思想是将数据（通常是键值对）通过哈希函数将数据的关键码转换为哈希值，进而通过哈希值快速找到元素对应的存储位置。
ps：哈希函数 hashFunc，将元素的关键码（如字符串、数字等）转换成一个固定范围内的整数，这个整数就是哈希值。
如果利用哈希构造一种存储结构，使得元素的存储位置与它的关键码之间能够建立起一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

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

这种通过哈希方法构造出来的结构称为哈希表(Hash Table)(或者称散列表)。

例如：在哈希表中，存储以下关键字序列{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % size; size为存储元素的表的长度。

在这里插入图片描述
如果继续向表中插入14时，通过hash函数计算出其位置为：hash(14) = 4;与关键字4计算出的哈希地址相同，发生了冲突，这种现象叫做哈希冲突或哈希碰撞。

2. 哈希冲突

哈希冲突：对于两个数据元素的关键字 k i k_i ki​和 k j k_j kj​(i != j)，有 k i k_i ki​ != k j k_j kj​，但有：Hash( k i k_i ki​) == Hash( k j k_j kj​)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
ps:把具有不同关键码而具有相同哈希地址的数据元素称为“同义词。
而引起哈希冲突的一个原因可能是：哈希函数设计不够合理。下面我们来了解一下常见的hash函数。

3. 哈希函数

哈希函数设计原则：

  1. 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。
  2. 哈希函数计算出来的地址能均匀分布在整个空间中。
  3. 哈希函数应该比较简单。

常见哈希函数：

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

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

4.哈希冲突解决

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

4.1 闭散列

闭散列，也叫开放定址法（Open Addressing），是一种处理哈希冲突的方法。当发生哈希冲突时，说明hash表没被填满，则表中必然存在空位置，因此我们可以通过探测算法在哈希表中寻找下一个空闲位置来存放元素。开放定址法的核心思想是通过一个探测算法在哈希表中一直探测，直到探测到空位置来解决冲突的。
常见的探测方法包括：线性探测、二次探测等。

4.1.1 线性探测

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
例如在上面的hash表中继续插入14时，通过hash函数计算出其位置为：hash(14) = 4;与关键字4计算出的哈希地址相同发生了冲突，因此我们使用线性探测找到下一个空位置，插入新元素。
在这里插入图片描述

4.1.2 采用线性探测的方式解决哈希冲突实现哈希表

关于哈希表结构的几点解释：

  • 哈希表存储元素的底层是个顺序表，我们这里直接采用vector来充当顺序表。
  • 底层存储的数据是存储的键值对，类型为 pair<K, V>，其中 K 是键的类型，V 是值的类型。
  • 由于采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如在上面的哈希表中删除元素4，如果直接删除掉，14查找起来可能会受影响。
    在这里插入图片描述因此，哈希表的每个位置不仅要存数据，还要存当前位置的状态，EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除。此时我们在删除掉4的同时将该位置的状态置为DELETE，后面再查找14的时候计算出14的存储位置为4，此时当前位置的状态为DELETE，需要继续往下一个位置查找，这样就可以保证删除元素不会影响其他元素的搜索。

存储结构的定义：

  • 由于表中每个位置既要存储元素，又要存储当前位置的状态，因此我们定义一个结构体 HashData 来存储每个位置的状态和数据。

HashData定义如下：

//所有状态
enum state
{
	EXIST,
	EMPTY,
	DELETE
};
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;//存储的键值对
	state _st;//状态
	//构造
	HashData(const pair<K, V>& kv = pair<K, V>())
		:_kv(kv)
		,_st(EMPTY)
	{}
};

哈希表的定义：

  • 哈希表中不仅要有存储数据的顺序表，还要维护一个成员变量来记录当前表中的元素个数，这是因为它可以帮助计算装载因子，判断是否需要扩容。
  • 装载因子（Load Factor）是哈希表中元素个数与哈希表大小的比值。当装载因子过高时，意味着哈希表中存储的元素数量接近了表的容量，此时在插入元素时可能会导致哈希冲突频繁，从而影响查找效率。为了避免装载因子过高导致的问题，我们因该在装载因子超过某个阈值（如0.7）时，自动扩展哈希表的容量（通常是原容量的两倍），并将现有元素重新分布到新的哈希表中。

在这里插入图片描述
哈希表的定义如下：

template<class K, class V, class Hash = HashFuc<K>>
class HastTable
{
public:
	//默认构造
	HastTable()
	{
		//初始时表的长度为10
		_table.resize(10);
		_n = 0;
	}
private:
	vector<HashData<K, V>> _table;
	int _n;//当前表中元素个数
};

哈希表的插入：
步骤如下：

  1. 判断是否需要扩容，这里设定载荷因子超过0.7时要进行扩容操作，将现有元素重新映射到新的哈希表中。
  2. 通过哈希函数获取待插入元素在哈希表中的位置。
  3. 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素；同时将该位置的状态改为EXIST, 表中个数+1。

例如：在哈希表中，依次插入一下关键字序列{1，7，6，4，5，9，11，14}；
画个图理解一下：
在这里插入图片描述
具体代码如下：

bool insert(const pair<K, V>& kv)
{
	//key已经存在 无法插入，不允许key相同
	if (find(kv.first)) return false;
	//负载因子超过0.7扩容
	if (_n * 10 / _table.size() == 7)
	{
		//扩容
		HastTable<K, V> newHT;
		newHT._table.resize(_table.size() * 2);
		for (size_t i = 0; i < _table.size(); ++i)
		{
			if (_table[i]._st == EXIST)
			{
				newHT.insert(_table[i]._kv);
			}
		}
		_table.swap(newHT._table);
	}
	Hash h;
	//通过hash函数计算当前插入元素的位置
	size_t hashi = h(kv.first) % _table.size();
	while (_table[hashi]._st == EXIST)
	{
		++hashi;
		hashi %= _table.size();
	}
	_table[hashi]._kv = kv;
	_table[hashi]._st = EXIST;
	++_n;
	return true;
}

哈希表的删除：

上面我们分析了，采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。因此在删除元素的时候采取伪删除，即要删除元素时，先去查找该元素，若找到了将该位置的标志改为DELETE即可。
具体代码如下：

bool erase(const K& k)
{
	//伪删除
	HashData<K, V>* ret = find(k);
	//找到了将该位置的标志改为DELETE，同时表中的元素个数-1
	if (ret)
	{
		ret->_st = DELETE;
		--_n;
		return true;
	}
	return false;
}

哈希表的查找：
步骤如下：

  1. 计算哈希值：使用哈希函数对键 k 进行哈希计算，得到哈希值，并将其映射到哈希表的索引范围内。
  2. 检查当前位置：循环检查哈希表中的索引位置，直到找到目标元素或者确认元素不存在。当前位置为空（状态为 EMPTY）：如果当前索引位置为空（状态为 EMPTY），表示该键不在哈希表中，可以直接返回 nullptr。当前位置已存在元素（状态为 EXIST）且键匹配：如果当前索引位置的状态为 EXIST 且键匹配，则找到了目标元素，返回该元素的指针。当前位置已存在元素但键不匹配：如果当前索引位置的状态为 EXIST 但键不匹配，继续检查下一个位置（线性探测）。
  3. 循环检查：继续检查下一个位置，直到找到目标元素或遇到一个空位置（状态为 EMPTY），表示该键不在哈希表中。
  4. 返回结果：如果找到了目标元素，返回该元素的指针；如果找不到，返回 nullptr。

具体代码如下：

HashData<K, V>* find(const K& k)
{
	Hash h;
	//计算哈希值
	size_t hashi = h(k) % _table.size();
	//循环检查：继续检查下一个位置，直到找到目标元素或遇到一个空位置
	while (_table[hashi]._st != EMPTY)
	{
		//如果当前索引位置的状态为 EXIST 且键匹配，则找到了目标元素，返回该元素的指针。
		if (_table[hashi]._st == EXIST && _table[hashi]._kv.first == k)
		{
			return &_table[hashi];
		}
		//如果当前索引位置的状态为 EXIST 但键不匹配，继续检查下一个位置（线性探测）。
		++hashi;
		hashi %= _table.size();
	}
	//遇到空位置（状态为 EMPTY），表示该键不在哈希表中，可以直接返回 nullptr。
	return nullptr;
}

总之，线性探测优点是实现非常简单；线性探测缺点是一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。 比如这组关键字序列：{4，5，14，15，24，6}，会造成冲突连成一片，导致效率降低。

4.1.3 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： H i H_i Hi​ = ( H 0 H_0 H0​ + i 2 i^2 i2 )% m, 或者： H i H_i Hi​ = ( H 0 H_0 H0​ - i 2 i^2 i2 )% m。其中：i = 1,2,3…， H 0 H_0 H0​是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。即每次探测不是往后探测一个位置，而是依次探测 1 2 1^2 12， 2 2 2^2 22， 3 2 3^2 32，…，这里就不在赘述，有兴趣的可以自己去实现一下。

4.2 开散列

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

例如：在哈希表中，存储以下关键字序列{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % size; size为存储元素的表的长度。

在这里插入图片描述
当继续插入元素14时，通过哈希函数计算出其存储位置为：hash(14) = 14 % 10 = 4；直接将其插入在位置为4的那个链表中即可。
在这里插入图片描述

4.2.2 采用链地址法的方式解决哈希冲突实现哈希表

存储结构的定义：

  • 由于每个桶都是一个单链表，因此哈希表里面存储的是每个桶的首节点的地址，所以存储底层为指针数组。而每个节点不仅要存储数据还要存储下一个节点的地址，因此我们定义一个结构体 HashNode。

HashNode定义如下：

template<class K, class V>
struct HashNode
{
	typedef HashNode<K, V> Node;
	pair<K, V> _kv;
	Node* _next;
	//构造
	HashNode(const pair<K, V>& kv)
		:_kv(kv)
		, _next(nullptr)
	{}

};

哈希表的定义：

  • 采用链地址法的方式解决哈希冲突实现哈希表也要维护一个成员变量来记录当前表中的元素个数，来帮助计算装载因子，判断是否需要扩容。

哈希表的定义如下：

template<class K, class V, class Hash = HashFuc<K>>
class HastTable
{
	typedef HashNode<K, V> Node;
public:
	//默认构造
	HastTable()
	{
		_table.resize(10);
		_n = 0;
	}
private:
	vector<Node*> _table;
	int _n;//当前表中元素个数
};

哈希表的插入：
步骤如下：

  1. 判断是否需要扩容，这里设定载荷因子超过1时要进行扩容操作，将现有元素重新映射到新的哈希表中。
    ps:关于这里的载荷因子为啥可以到1才进行扩容：桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。
  2. 通过哈希函数获取待插入元素在哈希表中的位置。
  3. 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素；同时将该位置的状态改为EXIST, 表中个数+1。

例如：在哈希表中，依次插入一下关键字序列{1，7，6，4，5，9，11，14, ，2 ，12，17}；
画个图理解一下：
在这里插入图片描述
具体代码如下：

bool insert(const pair<K, V>& kv)
{
	Hash h;
	if (find(kv.first)) return false;
	if (_n / _table.size() == 1)
	{
		//扩容
		HastTable<K, V, Hash> ht;
		ht._table.resize(_table.size() * 2);
		//遍历旧哈希表中的所有元素，将每个元素重新映射到新哈希表中。
		for (int i = 0; i < _table.size(); ++i)
		{
			Node* cur = _table[i];
			while (cur)
			{
				Node* next = cur->_next;
				int hashi = h(cur->_kv.first) % ht._table.size();
				cur->_next = ht._table[hashi];
				ht._table[hashi] = cur;
				cur = next;
			}
			_table[i] = nullptr;
		}
		_table.swap(ht._table);
	}
	//扩容完成后，将新元素插入到新的哈希表中。
	Node* newnode = new Node(kv);
	int hashi = h(kv.first) % _table.size();
	newnode->_next = _table[hashi];
	_table[hashi] = newnode;
	++_n;
	return true;
}

ps: 在扩完容后，将现有元素重新映射到新的哈希表时，要依次取旧表中的节点重新进行映射。这是因为重新链接节点通常比创建和插入新节点更高效，因为创建新节点涉及分配新的内存，而重新链接只需要调整指针。重新链接的开销较低，可以更快地完成扩容操作。

哈希表的删除：
删除步骤如下：

  1. 计算哈希值：使用哈希函数计算要删除元素的哈希值，并取模计算出其在哈希表中的索引。
  2. 查找元素：从计算出的索引开始，遍历链表，查找目标元素。
  3. 删除元素：如果找到目标元素，根据其在链表中的位置，调整链表指针以删除该节点。如果目标元素是链表中的第一个节点，将哈希表该位置指向下一个节点。如果目标元素在链表中间或末尾，将前一个节点的指针指向当前节点的下一个节点。释放被删除节点的内存，减少元素计数。
  4. 返回结果：如果找到并删除了目标元素，返回 true；否则，遍历结束后返回 false，表示未找到目标元素。

具体代码如下：

bool erase(const K& k)
{
	Hash h;
	int hashi = h(k) % _table.size();
	Node* prev = nullptr;
	Node* cur = _table[hashi];
	while (cur)
	{
		if (cur->_kv.first == k)
		{
			//删除
			if (prev == nullptr)
			{
				_table[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			delete cur;
			--_n;
			return true;
		}
		prev = cur;
		cur = cur->_next;
	}
	return false;
}

哈希表的查找：
步骤如下：

  1. 计算哈希值：使用哈希函数计算键的哈希值，并取模计算出其在哈希表中的索引位置。
  2. 遍历链表： 从计算出的索引位置开始，遍历链表，查找目标元素。
  3. 检查节点：如果当前节点不为空，检查当前节点的键是否等于目标键。
    如果找到目标键，返回 true，表示键存在。如果当前节点的键不等于目标键，继续遍历下一个节点。
  4. 返回结果：如果遍历链表结束后未找到目标键，返回 false，表示键不存在。

具体代码如下：

bool find(const K& k)
{
	Hash h;
	int hashi = h(k) % _table.size();
	Node* cur = _table[hashi];
	while (cur)
	{
		if (cur->_kv.first == k)
		{
			return true;
		}
		cur = cur->_next;
	}
	return false;
}

思考： 哈希函数采用处理余数法，被模的key必须要为整形才可以处理，而上面实现的hash表只能存储key为整形的元素，其他类型怎么解决？
要解决哈希表存储非整型键的问题，常见的做法是设计适用于各种键类型的哈希函数。这可以通过定义模板类和泛型哈希函数来实现，允许哈希表存储不同类型的键（如字符串、对象等）。
解决方案

  1. 模板类和泛型哈希函数：使用模板类定义哈希表，使其能够接受不同类型的键。为不同类型的键定义特定的哈希函数。模板特化和偏特化：对于标准类型（如整数、字符串等），可以定义特化的哈希函数。
  2. 对于自定义对象，可以重载哈希函数或者提供自定义哈希函数对象。

可以看到上面实现的hash表的第三个类模板参数可以接收使用者传的自定义哈希函数对象，来将key转换成整型。这个是字符串哈希算法（点击即可跳转）有兴趣的可以自己研究一下。
这里直接给出我的解决方案代码：

template<class K>
struct HashFuc
{
	unsigned long operator()(const K& K)
	{
		return (unsigned long)K;
	}
};
//模板特化 string版本
template<>
struct HashFuc<string>
{
	unsigned long operator()(const string& s)
	{
		unsigned long h = 0, g;

		for (auto e : s)
		{
			h = (h << 4) + e;
			if (g = h & 0xF0000000)
			{
				h ^= g >> 24;

			}
			h &= ~g;
		}
		return h;
	}
};

至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。

创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！

如果本篇博客有任何错误，请批评指教，不胜感激 ！！！
在这里插入图片描述

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

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

相关文章

CesiumJS【Basic】- #042 绘制纹理线（Primitive方式）

CesiumJS【Basic】- #042 绘制纹理线（Primitive方式）

文章目录 绘制纹理线（Primitive方式）1 目标2 代码2.1 main.ts3 资源文件绘制纹理线（Primitive方式） 1 目标 使用Primitive方式绘制纹理线 2 代码 2.1 main.ts var start = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);var
阅读更多...
爬虫逆向实战(41)-某巢登陆(AES、MD5、RSA、滑块验证码)

爬虫逆向实战(41)-某巢登陆(AES、MD5、RSA、滑块验证码)

一、数据接口分析 主页地址&#xff1a;某巢 1、抓包 通过抓包可以发现在登录时&#xff0c;网站首先请求captcha/querySlideImage/来获取滑块验证码的图片&#xff0c;然后请求captcha/checkCode/接口来验证滑块验证码。滑块验证码校验成功后&#xff0c;请求noshiro/getPu…
阅读更多...
使用explain优化慢查询的业务场景分析

使用explain优化慢查询的业务场景分析

问&#xff1a;你最害怕的事情是什么&#xff1f;答&#xff1a;搓澡问&#xff1a;为什么&#xff1f;答&#xff1a;因为有些人一旦错过&#xff0c;就不在了 Explain 这个词在不同的上下文中有不同的含义。在数据库查询优化的上下文中&#xff0c;“EXPLAIN” 是一个常用的 …
阅读更多...
矩阵置零解题

矩阵置零解题

给定一个 m x n 的矩阵&#xff0c;如果一个元素为 0 &#xff0c;则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。 示例 1&#xff1a; 输入&#xff1a;matrix [[1,1,1],[1,0,1],[1,1,1]] 输出&#xff1a;[[1,0,1],[0,0,0],[1,0,1]]示例 2&#xff1a; 输入&…
阅读更多...
UI（四）布局

UI（四）布局

文章目录 10、Navigator——路由器组件11、Pannel——可滑动面板12、Refresh——刷新组件13、RelativeContainer——相对布局组件14、Scroll——可滚动容器15、SideBarContainer——侧边栏容器16、Stack——堆叠容器17、Swiper——滑动块视图容器18、Tabs和TabContent——页签和…
阅读更多...
mac英语学习工具：Eudic欧路词典 for Mac 激活版

mac英语学习工具：Eudic欧路词典 for Mac 激活版

Eudic欧路词典是一款非常受欢迎的英语学习软件&#xff0c;它提供了丰富的词汇解释、例句、同义词、反义词等功能&#xff0c;帮助用户更好地理解和掌握英语单词。 以下是Eudic欧路词典的一些主要特点&#xff1a; 海量词汇库&#xff1a;Eudic欧路词典拥有庞大的词汇库&#…
阅读更多...
arm_uart4实验

arm_uart4实验

#include "uart4.h" //UART //初始化 void hal_uart4_init() { //rcc_init //…
阅读更多...
Google推出开源模型Gemma 2：性能大幅提升与创新训练方法

Google推出开源模型Gemma 2：性能大幅提升与创新训练方法

引言 近日&#xff0c;Google推出了开源模型Gemma 2&#xff0c;吸引了广大研究人员和开发者的关注。相比上一代模型&#xff0c;Gemma 2在性能和可用性方面实现了显著提升&#xff0c;提供了9B和27B两个版本&#xff0c;并且对外开放免费使用。本文将深入探讨Gemma 2的技术细…
阅读更多...
QueryClientProvider is not defined

QueryClientProvider is not defined

QueryClientProvider is not defined 运行一个svelte的项目&#xff0c;报错如上&#xff0c;前后查找解决不了&#xff0c;然后没办法&#xff0c; 本来是用yarn 安装的依赖&#xff0c;改用npm install&#xff0c;再次运行就成功了
阅读更多...
可燃气体报警器定期检测：优化与改进策略的探讨

可燃气体报警器定期检测：优化与改进策略的探讨

在现代化的工业环境中&#xff0c;可燃气体报警器的作用日益凸显。它们像是我们生产现场的安全卫士&#xff0c;时刻警惕着可能发生的危险&#xff0c;确保我们的工作环境安全、稳定。 然而&#xff0c;要确保这些“卫士”始终忠诚可靠&#xff0c;定期检测就显得尤为重要。 …
阅读更多...
【JVM面试题】总结-01

【JVM面试题】总结-01

【JVM面试题】总结-01 1. 介绍下Java内存区域(运行时数据区)1.1 程序计数器(线程私有)1.2 虚拟机栈(线程私有)1.3 本地方法栈(线程私有)1.4 Java堆(线程共享)1.5 方法区(线程共享)1.5.1 方法区和永久代的关系1.5.2 常用参数1.5.3 为什么要将永久代 (方法区) 替换为元空间 (Meta…
阅读更多...
WCCI 2024开幕，横滨圣地巡礼，畅游动漫与美食的世界

WCCI 2024开幕，横滨圣地巡礼，畅游动漫与美食的世界

惊喜&#xff01;WCCI 2024开幕&#xff0c;横滨圣地巡礼&#xff01;畅游动漫与美食的世界 会议之眼 快讯 会议介绍 IEEE WCCI&#xff08;World Congress on Computational Intelligence&#xff09;2024&#xff0c;即2024年IEEE世界计算智能大会&#xff0c;于6月30日至…
阅读更多...
写代码，为什么还需要作图？

写代码，为什么还需要作图？

引言 古人云 &#xff1a;一图胜千言&#xff0c;闲人说&#xff1a;无图无真相。 在日常的聊天工具当中&#xff0c;无论是使用微信&#xff0c;还是钉钉。使用图片或表情包的频次越来越高&#xff0c;那是为什么呢&#xff1f;其实在互联网没有那么发达的时候&#xff0c;我…
阅读更多...
Adobe Premiere 视频编辑软件下载安装，pr全系列分享 轻松编辑视频

Adobe Premiere 视频编辑软件下载安装，pr全系列分享 轻松编辑视频

Adobe Premiere&#xff0c;自其诞生之日起&#xff0c;便以其卓越的性能和出色的表现&#xff0c;稳坐视频编辑领域的王者宝座&#xff0c;赢得了无数专业编辑人员与广大爱好者的青睐。这款强大的视频编辑软件&#xff0c;凭借其丰富的功能和灵活的操作性&#xff0c;为用户提…
阅读更多...
（1）Jupyter Notebook 下载及安装

（1）Jupyter Notebook 下载及安装

目录 1. Jupyter Notebook是什么&#xff1f;2. Jupyter Notebook特征3. 应用3. 利用Google Colab安装Jupyter Notebook3.1 什么是 Colab&#xff1f;3.2 访问 Google Colab 1. Jupyter Notebook是什么&#xff1f; 百度百科: Jupyter Notebook&#xff08;此前被称为 IPython …
阅读更多...
函数创建单链表---无n型，需要 while 循环 + scanf

函数创建单链表---无n型，需要 while 循环 + scanf

题目&#xff1a; #include <stdlib.h> struct link{int data;struct link *next; }; struct link* creatLink(); int main(){struct link *head,*p;headcreatLink();for(phead->next ;p;pp->next )printf("%d ",p->data );return 0; }/* 请在这里填…
阅读更多...
501、二叉搜索树中的众数

501、二叉搜索树中的众数

给你一个含重复值的二叉搜索树&#xff08;BST&#xff09;的根节点 root &#xff0c;找出并返回 BST 中的所有 众数&#xff08;即&#xff0c;出现频率最高的元素&#xff09;。如果树中有不止一个众数&#xff0c;可以按 任意顺序 返回。 假定 BST 满足如下定义&#xff1…
阅读更多...
泛微E9开发 根据故障来源新增明细行，并且初始化错误类型

泛微E9开发 根据故障来源新增明细行，并且初始化错误类型

根据故障来源新增明细行&#xff0c;并且初始化错误类型 1、需求说明2、实现方法3、扩展知识点3.1 批量修改字段值或显示属性3.1.1 格式3.1.2 参数3.1.3 演示 3.2 根据字段ID获取字段信息3.2.1 格式3.2.2 参数3.2.3 演示 1、需求说明 用户对出现故障的机器或设备进行判断问题判…
阅读更多...
第十四届蓝桥杯省赛C++A组F题【买瓜】题解（AC）

第十四届蓝桥杯省赛C++A组F题【买瓜】题解（AC）

70pts 题目要求我们在给定的瓜中选择一些瓜&#xff0c;可以选择将瓜劈成两半&#xff0c;使得最后的总重量恰好等于 m m m。我们的目标是求出至少需要劈多少个瓜。 首先&#xff0c;我们注意到每个瓜的重量最多为 1 0 9 10^9 109&#xff0c;而求和的重量 m m m 也最多为…
阅读更多...
Linux高并发服务器开发（八）Socket和TCP

Linux高并发服务器开发（八）Socket和TCP

文章目录 1 IPV4套接字结构体2 TCP客户端函数 3 TCP服务器流程函数代码粘包 4 三次握手5 四次挥手6 滑动窗口 1 IPV4套接字结构体 2 TCP客户端 特点&#xff1a;出错重传 每次发送数据对方都会回ACK&#xff0c;可靠 tcp是打电话的模型&#xff0c;建立连接 使用连接 关闭连接…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023