【Cpp】哈希之手撕闭散列/开散列

news2024/11/25 10:34:37

文章目录

  • unordered
    • unordered系列关联式容器
    • unordered_map和unordered_set概述
      • unordered_map的文档介绍
      • unordered_map的接口说明
    • 底层结构
  • 哈希
    • 哈希/散列表 概念
    • 哈希冲突
    • 哈希函数
      • 哈希函数设计原则:
      • 常见哈希函数
    • 哈希冲突解决
      • 闭散列
        • 线性探测
        • 二次探测
      • 开散列
  • 哈希表的代码实现
    • 闭散列法/开放定址法
      • 大致框架:
      • insert()
        • 扩容
        • 扩容的传统写法
        • 扩容的现代写法
        • insert代码
      • find()
      • erase
    • 开放定址法总代码
    • 开散列法/链地址法/开链法
      • 基本框架
      • Find写法
      • Erase写法
      • Insert写法
    • 链地址法总代码

unordered

unordered系列关联式容器

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

unordered_map和unordered_set概述

底层是哈希表,迭代器遍历是无序的,是单向迭代器
其他的用法和map,set没有什么区别

unordered_map的文档介绍

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

unordered_map的接口说明

函数声明功能介绍
bool empty()const检测是否为空
size_t size()const获取有效元素个数
begin返回第一个元素的迭代器
end返回最后一个元素的下一个位置的迭代器
cbegin返回第一个元素的const迭代器
cend返回最后一个元素的下一个位置的const迭代器
operator[]返回与key对应的value,没有一个默认值
iterator find(const K& key)返回key在哈希桶中的位置
size_t count(const K& key)返回哈希桶中关键码伪key的键值对的个数
insert向容器中插入键值对
erase删除容器中的键值对
void clear()清空容器中有效元素个数
void swap(unordered_map &)交换两个容器中的元素
size_t bucket_count()const返回哈希桶中桶的总个数
size_t bucket_size(size_t n)const返回n号桶中有效元素的总个数
size_t bucket(const K& key)返回元素key所在的桶号

底层结构

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

哈希

哈希/散列表 概念

简单来说:key和存储位置建立一个对应关系

顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系,因此在查找一个元素时,必须要经过关键码的多次比较。顺序查找时间复杂度为O(N),平衡树中为树的高度,即O( l o g 2 N log_2 N log2N),搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素。
如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素.
当向该结构中:

  • 插入元素:
    根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素:
    对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则搜索成功
    该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table)(或者称散列表)
    例如:数据集合{1,7,6,4,5,9};
    哈希函数设置为:hash(key) = key % capacity; capacity为存储元素底层空间总的大小
    ![[Pasted image 20230524184844.png]]

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

哈希冲突

对于两个数据元素的关键字 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),即:不同关键字通过相同哈希哈数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”
哈希冲突只能尽可能避免,很难完全解决:

  1. 设置更好的哈希函数,减少冲突
  2. 设置更好的解决冲突的方式

哈希函数

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

哈希函数设计原则:

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

常见哈希函数

  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种不同的符号在各位上出现的频率不一定
    相同,可能在某些位上分布比较均匀,每种符号出现的机会均等,在某些位上分布不均匀只
    有某几种符号经常出现。可根据散列表的大小,选择其中各种符号分布均匀的若干位作为散
    列地址。例如:
    ![[Pasted image 20230524185349.png]]

假设要存储某家公司员工登记表,如果用手机号作为关键字,那么极有可能前7位都是相同的,那么我们可以选择后面的四位作为散列地址,如果这样的抽取工作还容易出现 冲突,还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法
数字分析法通常适合处理关键字位数比较大的情况,并且事先知道关键字的分布且关键字的若干位分布较均匀的情况
注意:哈希函数设计的越精妙,产生哈希冲突的可能性就越低,但是无法避免哈希冲突

哈希冲突解决

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

闭散列

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

线性探测

比如2.1中的场景,现在需要插入元素44,先通过哈希函数计算哈希地址,hashAddr为4,因此44理论上应该插在该位置,但是该位置已经放了值为4的元素,即发生哈希冲突。
线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止。

  • 插入
    通过哈希函数获取待插入元素在哈希表中的位置
    如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,
    使用线性探测找到下一个空位置,插入新元素
  • 删除
    采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索。比如删除元素4,如果直接删除掉,44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

我们查找是一直查到表为空为止,如果使用真删除的方法,就会导致还没有查找完就提前结束了

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

线性探测优点:实现非常简单,
线性探测缺点:一旦发生哈希冲突,所有的冲突连在一起,容易产生数据“堆积”,即:不同关键码占据了可利用的空位置,使得寻找某关键码的位置需要许多次比较,导致搜索效率降低。我们可以使用’二次探测’等方法缓解

二次探测

线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位置的方式就是挨着往后逐个去找,因此二次探测为了避免该问题,找下一个空位置的方法为: 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是表的大小。
对于2.1中如果要插入44,产生冲突,使用解决后的情况为
![[Pasted image 20230524190310.png]]

研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出必须考虑增容
因此:散列最大的缺陷就是空间利用率比较低,这也是哈希的缺陷

开散列

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

![[Pasted image 20230524190643.png]]

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

哈希表的代码实现

闭散列法/开放定址法

大致框架:

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<vector>
namespace OpenAdress
{
	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 HashTable
	{
	public:
		bool insert(const pair<K, V>& kv)
		{
			
		}

		HashData<K, V>* Find(const K& key)
		{

		}

		bool Erase(const K& key)
		{

		}

	private:
		vector<HashData<K, V>> _tables;//哈希表依赖于vector
		size_t _n = 0;//存储的有效数据个数,默认为0,一定要加这个默认值
	};
}

insert()

扩容

插入会涉及到扩容
扩容会有一个负载因子的概念
![[Pasted image 20230524193557.png]]

扩容的传统写法

//此处我们设置负载因子不超过0.7
//检查负载因子,看是否需要扩容

//这里乘十是因为整形除以整形还是整形,会导致死循环
//也可以强制类型转换: if((double)_n / (double) _tables.size() >= 0.7)

if (_tables.size() == 0 || 10 * (_n) / _tables.size() >= 7)
{
	//第一种方法:遍历旧表,重新映射到新表
	//扩容的时候一定要考虑size为0的情况,否则会死循环
	size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
	vector<HashData<K, V>> newtables;//创建新表
	//遍历旧表,重新映射:
	for (auto& data : _tables)
	{
		if (data._state == EXIST)
		{
			size_t i = 1;
			//计算hashi
			size_t hashi = data._kv.first % newtables.size();
			size_t index = hashi;
			while (newtables[index]._state == EXIST)
			{
				index = hashi + i;
				//这里是防止一直没有找到
				index %= newtables.size();
				++i;
			}
			newtable[index]._kv = data._kv;
			newtable[index]._state = EXIST;
		}
	}
}

扩容的现代写法

我们可以复用insert

if (_tables.size() == 0 || 10 * (_n) / _tables.size() >= 7)
	{
		size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
		HashTable<K, V> newht;
		newht._tables.resize(newsize);

		for (auto& data : _tables)//这里遍历的是每一个节点!
		{
			if (data._state == EXIST)
			{
				newht.insert(data._kv);
			}
		}
		_tables.swap(newht._tables);
	}

insert代码

bool insert(const pair<K, V>& kv)
	{
		if (Find(kv.first))
		{
			return false;
		}

		if (_tables.size() == 0 || 10 * (_n) / _tables.size() >= 7)
		{
			size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			HashTable<K, V> newht;
			newht._tables.resize(newsize);

			for (auto& data : _tables)
			{
				if (data._state == EXIST)
				{
					newht.insert(data._kv);
				}
			}
			_tables.swap(newht._tables);
		}	
		
		size_t hashi = kv.first % _tables.size();
		size_t i = 1;
		size_t index = hashi;
		
		while (_tables[index]._state == EXIST)
		{
			index = hashi + i;
			index = index % _tables.size();
			++i;
		}

		_tables[index]._kv = kv;
		_tables[index]._state = EXIST;
		++_n;
		return true;
	}

find()

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

		size_t hashi = key % _tables.size();
		size_t i = 1;
		size_t index = hashi;
		while (_tables[index]._state != EMPTY)
		{
			if (_tables[index]._state == EXIST && _tables[index]._kv.first == key)
			{
				return _tables[index]._kv;
			}
			index = hashi + i;
			index %= _tables.size();
			++i;

			//如果已经找了一圈,那么说明全是存在+删除
			if (index == hashi)
			{
				break;
			}
		}
		return nullptr;
	}

erase

bool Erase(const K& key)
	{
		//先找到key对应的地址
		HashData<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
			return true;
		}
		else
		{
			return false;
		}
	}

简单来说,就是通过find找到KV地址,然后修改状态,_n--即可

开放定址法总代码

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<vector>

namespace OpenAdress
{
	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 HashTable
	{
	public:
		bool insert(const pair<K, V>& kv)
		{
			//如果插入的数据已经存在,则返回false
			if (Find(kv.first))//找到了
			{
				return false;
			}

			//检查负载因子(我们这里设置为0.7),看是否需要扩容
			//这里乘十是因为整形除以整形还是整形,会导致死循环
			//if((double)_n / (double) _tables.size() >= 0.7)
			if (_tables.size() == 0 || 10 * (_n) / _tables.size() >= 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newht;
				newht._tables.resize(newsize);

				//遍历旧表,重新得到新表
				for (auto& data : _tables)
				{
					if (data._state == EXIST)
					{
						newht.insert(data._kv);
					}
				}
				_tables.swap(newht._tables);
			}
			
			size_t hashi = kv.first % _tables.size();

			//线性探测
			size_t i = 1;
			size_t index = hashi;
			while (_tables[index]._state == EXIST)
			{
				index = hashi + i;
				index = index % _tables.size();
				++i;
			}

			_tables[index]._kv = kv;
			_tables[index]._state = EXIST;
			++_n;
			return true;
		}

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

			size_t hashi = key % _tables.size();
			size_t i = 1;
			size_t index = hashi;
			while (_tables[index]._state != EMPTY)
			{
				if (_tables[index]._state == EXIST && _tables[index]._kv.first == key)
				{
					return _tables[index]._kv;
				}
				index = hashi + i;
				index %= _tables.size();
				++i;

				//如果已经找了一圈,那么说明全是存在+删除
				if (index == hashi)
				{
					break;
				}
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			//先找到key对应的地址
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}

	private:
		vector<HashData<K, V>> _tables;//哈希表依赖于vector
		size_t _n = 0;//存储的有效数据个数,默认为0,一定要加这个默认值
	};
}

开散列法/链地址法/开链法

基本框架

namespace HashBucket
{
	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 HashTable
	{
		typedef HashNode<K,V> Node;
	public:
		~HashTable()
		{
			for (auto& cur : _tables)
			{
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				cur = nullptr;
			}
		}

		Node* Find(const K& key)
		{

		}

		bool Erase(const K& key)
		{

		}

		bool insert(const pair<K, V>& kv)
		{

		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};

}

Find写法

Node* Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return nullptr;
		}

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

Erase写法

bool Erase(const K& key)
	{
		if (_tables.size() == 0)
		{
			return false;
		}
		size_t hashi = key % _tables.size();
		Node* cur = _tables[hashi];
		Node* prev = nullptr;
		while (cur)
		{
			if (cur._kv.first == key)
			{
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}
				delete cur;

				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}

Insert写法

bool insert(const pair<K, V>& kv)
	{
		if (_tables.size() == 0)
		{
			return false;
		}
		//负载因子为1时扩容
		if (_n == _tables.size())
		{
			size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			//记得全部置为nullptr!
			vector<Node*> newtables(newsize, nullptr);
			for (auto& cur : _tables)
			{
				while (cur)
				{
					Node* next = cur->next;
					size_t hashi = cur._kv.first % newtables.size();
					//头插到新表
					cur->next = newtables[hashi];
					newtables[hashi] = cur;

					cur = next;
				}
			}
			_tables.swap(newtables);
		}
	}

链地址法总代码

namespace HashBucket
{
	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 HashTable
	{
		typedef HashNode<K,V> Node;
	public:
		~HashTable()
		{
			for (auto& cur : _tables)
			{
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				cur = nullptr;
			}
		}

		Node* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}

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

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur._kv.first == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;

					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

		bool insert(const pair<K, V>& kv)
		{
			if (_tables.size() == 0)
			{
				return false;
			}
			//负载因子为1时扩容
			if (_n == _tables.size())
			{
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				//记得全部置为nullptr!
				vector<Node*> newtables(newsize, nullptr);
				for (auto& cur : _tables)
				{
					while (cur)
					{
						Node* next = cur->next;
						size_t hashi = cur._kv.first % newtables.size();
						//头插到新表
						cur->next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}
				}
				_tables.swap(newtables);
			}
		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};

}

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

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

相关文章

C语言数据结构——树、堆(堆排序)、TOPK问题

&#x1f436;博主主页&#xff1a;ᰔᩚ. 一怀明月ꦿ ❤️‍&#x1f525;专栏系列&#xff1a;线性代数&#xff0c;C初学者入门训练&#xff0c;题解C&#xff0c;C的使用文章&#xff0c;「初学」C&#xff0c;数据结构 &#x1f525;座右铭&#xff1a;“不要等到什么都没…

使用go语言构建区块链 Part4.事务1

英文源地址 简介 事务是比特币的核心, 区块链的唯一目的是以安全可靠的方式存储交易, 因此在交易创建后没有人可以修改. 今天我们开始实现事务, 但由于这是一个相当大的主题, 我将它分成两部分: 在这一部分中, 我们将实现事务的通用机制, 在第二部分中, 我们将研究细节. 此外…

让你在Windows打开Sketch格式再也不愁

Sketch是Macos的专用矢量绘图应用。在Sketch软件中&#xff0c;ios开发者可以轻松设计图层面板等图层的常用操作&#xff0c;广泛应用于产品的交互设计和UI设计&#xff0c;帮助很多设计师创作出很多优秀的作品。然而&#xff0c;Sketch只服务于Macos系统&#xff0c;这使得许多…

Laravel框架06:文件、迁移填充、会话、缓存

Laravel框架06&#xff1a;文件、迁移填充、会话、缓存 一、文件上传1. 文件上传表单2. 上传业务处理3. 全部代码 二、数据表的迁移与填充1. 迁移文件① 创建迁移文件② 编写迁移文件③ 执行迁移文件④ 回滚迁移文件 2. 填充&#xff08;种子&#xff09;文件① 创建填充文件②…

C++常用的支持中文的GUI库Qt 6之三: Qt 6的项目的发布

C常用的支持中文的GUI库Qt 6之三&#xff1a; Qt 6的项目的发布 本文接着上一篇“C常用的支持中文的GUI库Qt 6之二&#xff1a;项目的结构、资源文件的使用” https://blog.csdn.net/cnds123/article/details/130741807介绍&#xff0c;并使用其中的例子。 程序代码能正确编译…

【STL】list的使用

系列文章 学习C途中自然绕不过STL&#xff0c;在这个系列文章之中 我们讲了string的使用和string的模拟实现&#xff0c;以及vector的使用、vector的模拟实现。 感兴趣的可以翻翻看。 目录 系列文章 前言 默认成员函数 构造函数 拷贝构造 赋值重载 迭代器 容量查询 …

人人都能看懂的Spring源码解析,Spring声明式事务关于传播特性、事务挂起与恢复的处理

人人都能看懂的Spring源码解析&#xff0c;Spring声明式事务关于传播特性、事务挂起与恢复的处理 原理解析AbstractPlatformTransactionManager事务传播特性事务挂起与恢复通过DataSourceTransactionManager看事务挂起和恢复的具体实现 代码走读总结 往期文章&#xff1a; 人人…

LRU Cache

前言 哈喽&#xff0c;各位小伙伴大家好&#xff0c;本章内容为大家介绍计算机当中为了提高数据相互传输时的效率而引进的一种重要设计结构叫做LRU Cache,下面将为大家详细介绍什么是LRU Cache,以及它是如何是实现的&#xff0c;如何提升效率的。 1.什么是LRU Cache? LRU是L…

卷起来了?2023这三个项目直接让你原地起飞!

理论自学谁不会&#xff0c;理论知识跟实战项目实践相结合才是大问题&#xff1f; 还在发愁没有项目练手&#xff1f;还在发愁简历中的项目生搬硬凑&#xff1f;还在担心自己没实操过项目被面试官直接K.O? 这三个实战项目让你快人一步&#xff0c;总有一个适合你的&#xff…

数慧时空20年磨一剑:推出智能遥感云平台DIEY,自然资源多模态大模型“长城”,为地理信息产业提速

作者 | 伍杏玲 出品 | CSDN 据中国地理信息产业发展报告公布的数据&#xff0c;截至2020年末&#xff0c;行业从业单位13.8万家&#xff0c;从业人数336.6万&#xff0c;到2021年末&#xff0c;从业单位增加到16.4万家&#xff0c;从业人数增加到398万&#xff0c;产业规模越…

软件测试的未来?为什么越来越多的公司选择模糊测试

背景&#xff1a;近年来&#xff0c;随着信息技术的发展&#xff0c;各种新型自动化测试技术如雨后春笋般出现。其中&#xff0c;模糊测试&#xff08;fuzz testing&#xff09;技术开始受到行业关注&#xff0c;它尤其适用于发现未知的、隐蔽性较强的底层缺陷。这里&#xff0…

Eclipse MAT分析内存案例

前言 本文记录一次使用Eclipse MAT排查内存问题的案例&#xff0c;缘由是线上某服务OOM&#xff0c;排查得知jvm old区占满&#xff0c;但是gc了还是无法释放 实战 首先在线上服务器排查发现某应用占用了大量的内存&#xff0c;由一个ConcurrentHashMap对象造成的&#xff0…

【ArcGIS Pro二次开发】(31):ArcGIS Pro中的多线程

ArcGIS Pro与旧的ArcGIS桌面应用程序的显著不同之处在于&#xff0c;它采用多线程架构&#xff0c;可以有效的发挥多核CPU的优势。这使得二次开发工具的性能变得更好&#xff0c;但也对开发工作带来了更多的难点和挑战。 一、多线程需要注意的问题 一般情况下&#xff0c;为了…

尚硅谷MyBatis-Plus笔记001【简介、入门案例、基本CRUD】

视频地址&#xff1a;【尚硅谷】MyBatisPlus教程&#xff08;一套玩转mybatis-plus&#xff09;_哔哩哔哩_bilibili 尚硅谷MyBatis-Plus笔记01【简介、入门案例、基本CRUD】 尚硅谷MyBatis-Plus笔记02【】 尚硅谷MyBatis-Plus笔记03【】 尚硅谷MyBatis-Plus笔记04【】 尚硅谷…

非暴力沟通--日常沟通的技巧与实践

这篇文章是我在公司团队内部做的分享的演讲稿 开场白 大家好&#xff0c;我今天要分享的主题是非暴力沟通–日常沟通的技巧与实践。 介绍非暴力沟通这本书 分享这个主题的原因是我最近看了一本书&#xff0c;叫做《非暴力沟通》&#xff0c;这本书是美国一个叫做马歇尔卢森堡…

MFC CListCtrl 显示图片

MFC CListCtrl 显示图片 MFC CListCtrl 显示图片PreCreateWindow中设置风格没有起作用在OnCreate中设置CListCtrl的风格最合适在OnInitialUpdate中添加数据最合适需要设置CImageList&#xff0c;资源是我自己搞的一个图片资源ps:参考链接 MFC CListCtrl 显示图片 在使用MFC的C…

Codeforces Round 764 (Div. 3)

比赛链接 Codeforces Round 764 A. Plus One on the SubsetB. Make APC. Division by Two and PermutationD. Palindromes ColoringE. Masha-forgetful A. Plus One on the Subset Example input 3 6 3 4 2 4 1 2 3 1000 1002 998 2 12 11output 3 4 1题意&#xff1a; 你可…

怎么学习机械学习相关的技术?

学习机器学习相关技术的过程可以分为以下几个步骤&#xff1a; 掌握基本数学和统计知识&#xff1a; 机器学习建立在数学和统计学的基础上&#xff0c;了解线性代数、概率论、统计学等基本概念和方法对于理解机器学习算法至关重要。 学习编程和数据处理&#xff1a; 掌握一门…

kafka基础介绍

目录 前言&#xff1a; 一:kafka架构 1.kafka基础架构 2、kafka多副本架构 二、kafka基础概念 1、produce 2. Consumer 3、Broker ​ 4、Topic 5、Partition 6、Replicas 7、Offset 8、 AR 9、 ISR 10、OSR 11、HW 12、LEO 13、Lag 三、kafka特性 四、kafka…

总结加载Shellcode的各种方式

1.内联汇编加载 使用内联汇编只能加载32位程序的ShellCode&#xff0c;因为64位程序不支持写内联汇编 #pragma comment(linker, "/section:.data,RWE") //将data段的内存设置成可读可写可执行 #include <Windows.h>//ShellCode部分 unsigned char buf[] &qu…