【C++】哈希表实现

news2024/12/22 13:20:03

目录

一、哈希概念

1.1 直接定址法

1.2 哈希冲突

1.3 负载因子

1.4 将关键字转为整数

二、哈希函数

2.1 除法散列法/除留余数法

2.2 乘法散列图（了解即可）

2.3 全域散列法（了解即可）

​编辑

三、处理哈希冲突

3.1 开放定址法

线性探测

二次探测

双重散列（了解）

开放定址法代码实现

开放定址法的哈希表结构

扩容 

 key不能取模的问题

完整代码实现

四、链地址法

解决冲突的思路

扩容 

完整代码

一、哈希概念

哈希(hash)又称散列，是一种组织数据的方式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建立一个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进行快速查找。

1.1 直接定址法

当关键字的范围比较集中时，直接定址法就是非常简单高效的方法，比如一组关键字都在[0,99]之间，那么我们开一个100个数的数组，每个关键字的值直接就是存储位置的下标。再比如一组关键字值都在[a,z]的小写字母，那么我们开一个26个数的数组，每个关键字acsii码-a ascii码就是存储位置的下标。也就是说直接定址法本质就是用关键字计算出一个绝对位置或者相对位置

1.2 哈希冲突

直接定址法的缺点也非常明显，当关键字的范围比较分散时，就很浪费内存甚至内存不够用。假设我们只有数据范围是[0, 9999]的N个值，我们要映射到一个M个空间的数组中(一般情况下M >= N)，那么就要借助哈希函数(hash function)hf，关键字key被放到数组的h(key)位置，这里要注意的是h(key)计算出的值必须在[0, M)之间。

这里存在的一个问题就是，两个不同的key可能会映射到同一个位置去，这种问题我们叫做哈希冲突，或者哈希碰撞。理想情况是找出一个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的，所以我们尽可能设计出优秀的哈希函数，减少冲突的次数，同时也要去设计出解决冲突的方案。

1.3 负载因子

假设哈希表中已经映射存储了N个值，哈希表的⼤⼩为M，那么 负载因子等于N/M，负载因⼦有些地⽅也翻译为载荷因⼦/装载因⼦等，他的英⽂为load factor。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低

1.4 将关键字转为整数

我们将关键字映射到数组中位置，一般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，这个细节我们后面代码实现中再进行细节展示。下面哈希函数部分我们讨论时，如果关键字不是整数，那么我们讨论的Key是关键字转换成的整数。

二、哈希函数

一个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个方向去考量设计。

2.1 除法散列法/除留余数法

除法散列法也叫做除留余数法，顾名思义，假设哈希表的大小为M，那么通过key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key) = key % M。

当使用除法散列法时，要尽量避免M为某些值，如2的幂，10的幂等。如果是2^X ，那么key % 2^X
本质相当于保留key的后X位，那么后X位相同的值，计算出的哈希值都是一样的，就冲突了。如：
{63 , 31}看起来没有关联的值，如果M是16，也就是 2^4，那么计算出的哈希值都是15，因为63的二进制后8位是 00111111，31的二进制后8位是 00011111。如果是 10^X，就更明显了，保留的都是10进值的后x位，如：{112, 12312}，如果M是100，也就是 10^2，那么计算出的哈希值都是12。

当使用除法散列法时，建议M取不太接近2的整数次幂的一个质数(素数)。

需要说明的是，实践中也是八仙过海，各显神通，Java的HashMap采用除法散列法时就是2的整数次幂做哈希表的大小M，这样玩的话，就不用取模，而可以直接位运算，相对而言位运算比模更高效一些。但是他不是单纯的去取模，比如M是2^16次方，本质是取后16位，那么用key’ =key>>16，然后把key和key' 异或的结果作为哈希值。也就是说我们映射出的值还是在[0,M)范围内，但是尽量让key所有的位都参与计算，这样映射出的哈希值更均匀一些即可。

2.2 乘法散列图（了解即可）

2.3 全域散列法（了解即可）

三、处理哈希冲突

实践中哈希表⼀般还是选择除法散列法作为哈希函数，当然哈希表⽆论选择什么哈希函数也避免不了冲突，那么插⼊数据时，如何解决冲突呢？主要有两种两种⽅法，开放定址法和链地址法。

3.1 开放定址法

在开放定址法中所有的元素都放到哈希表里，当一个关键字key用哈希函数计算出的位置冲突了，则按照某种规则找到一个没有存储数据的位置进行存储，开放定址法中负载因子一定是小于的。这里的规则有三种：线性探测、二次探测、双重探测。

线性探测

从发生冲突的位置开始，依次线性向后探测，直到寻找到下一个没有存储数据的位置为止，如果走
到哈希表尾，则回绕到哈希表头的位置。

线性探测的比较简单且容易实现，线性探测的问题假设，hash0位置连续冲突，hash0，hash1，
hash2位置已经存储数据了，后续映射到hash0，hash1，hash2，hash3的值都会争夺hash3位
置，这种现象叫做群集/堆积。下面的二次探测可以一定程度改善这个问题。

下面演示 {19,30,5,36,13,20,21,12} 等这一组值映射到M=11的表中。

h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) =10，h(12) = 1

简单举个栗子： 

//hashTable.h
#pragma once
#include<vector>
#include<iostream>

using namespace std;

enum State
{
	EXIST,
	EMPTY,
	DELETE
};

template<class K,class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};

template<class K,class V>
class HashTable
{
public:
	HashTable()
		:_tables(11)
		, _n(0)
	{}

	bool Insert(const pair<K, V>& kv)
	{
		size_t hash0 = kv.first % _tables.size();
		size_t hashi = hash0;
		size_t i = 1;
		while (_tables[hashi]._state == EXIST)
		{	//线性探测
			hashi = (hash0 + i) % _tables.size();
			i++;
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		_n++;

		return true;
	}

private:
	vector<HashData<K, V>> _tables;
	size_t _n; //记录数据个数
};

//text.cpp
#include<iostream>
#include"hashTable.h"

using namespace std;

int main()
{
	//int a[] = { 19,30,52,63,11,22 };
	int a[] = { 19,30,5,36,13,20,21,12 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.Insert({ e,e });
	}

	return 0;
}

但是有个问题就是如果表满了，探测不到一个新位置，就会死循环，所以这里要控制负载因子

二次探测

从发生冲突的位置开始，依次左右按二次方跳跃式探测，直到寻找到下一个没有存储数据的位置为止，如果往右走到哈希表尾，则回绕到哈希表头的位置；如果往左走到哈希表头，则回绕到哈希表尾的位置；

下面演示 {19,30,52,63,11,22} 等这一组值映射到M=11的表中

h(19) = 8, h(30) = 8, h(52) = 8, h(63) = 8, h(11) = 0, h(22) = 0 

双重散列（了解）

下面演示 {19,30,52,74} 等这一组值映射到M=11的表中，设 h 2(key) = key%10 + 1

开放定址法代码实现

开放定址法的哈希表结构

enum State
{
	EXIST,
	EMPTY,
	DELETE
};
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};
template<class K, class V>
class HashTable
{
private:
	vector<HashData<K, V>> _tables;
	size_t _n = 0; // 表中存储数据个数
};

要注意的是这里需要给每个存储值的位置加一个状态标识，否则删除一些值以后，会影响后面冲突的值的查找。如下图，我们删除30，会导致查找20失败，当我们给每个位置加一个状态标识
{EXIST,EMPTY,DELETE} ，删除30就可以不用删除值，而是把状态改为DELETE ，那么查找20
时是遇到EMPTY 才能，就可以找到20。

h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) =10，h(12) = 1 

扩容 

 这里我们哈希表负载因子控制在0.7，当负载因子到0.7以后我们就需要扩容了，我们还是按照2倍扩容，但是同时我们要保持哈希表大小是一个质数，第一个是质数，2倍后就不是质数了。那么如何解决了，一种方案就是上面1.4.1除法散列中我们讲的Java HashMap的使用2的整数幂，但是计算时不能直接取模的改进方法。另外一种方案是sgi版本的哈希表使用的方法，给了一个近似2倍的质数表，每次去质数表获取扩容后的大小。

inline unsigned long __stl_next_prime(unsigned long n)
{
	// Note: assumes long is at least 32 bits.
	static const int __stl_num_primes = 28;
	static const unsigned long __stl_prime_list[__stl_num_primes] =

{
	53, 97, 193, 389, 769,
	1543, 3079, 6151, 12289, 24593,
	49157, 98317, 196613, 393241, 786433,
	1572869, 3145739, 6291469, 12582917, 25165843,
	50331653, 100663319, 201326611, 402653189, 805306457,
	1610612741, 3221225473, 4294967291
};
	const unsigned long* first = __stl_prime_list;
	const unsigned long* last = __stl_prime_list + __stl_num_primes;
	const unsigned long* pos = lower_bound(first, last, n);
	return pos == last ? *(last - 1) : *pos;
}

 key不能取模的问题

当key是string/Date等类型时，key不能取模，那么我们需要给HashTable增加一个仿函数，这个仿函数支持把key转换成一个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现一个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。string做哈希表的key非常常见，所以我们可以考虑把string特化一下。

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
{
	return (size_t)key;
}
};
// 特化
template<>
struct HashFunc<string>
{
	// 字符串转换成整形，可以把字符ascii码相加即可
	// 但是直接相加的话，类似"abcd"和"bcad"这样的字符串计算出是相同的
	// 这⾥我们使⽤BKDR哈希的思路，⽤上次的计算结果去乘以⼀个质数，这个质数⼀般去31, 131
等效果会⽐较好
size_t operator()(const string& key)
{
	size_t hash = 0;
	for (auto e : key)
{
	hash *= 131;
	hash += e;
}
	return hash;
}
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
private:
	vector<HashData<K, V>> _tables;
	size_t _n = 0; // 表中存储数据个数
};

完整代码实现

#include<iostream>
#include<vector>
using namespace std;

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return size_t key;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto ch : s)
		{
			hash += ch;
			hash * 131;
		}

		return hash;
	}
};
inline unsigned long __stl_next_prime(unsigned long n)
{
	static const int __stl_num_primes = 28;
	static const unsigned long __stl_prime_list[__stl_num_primes] =
	{
	53, 97, 193, 389, 769,
	1543, 3079, 6151, 12289, 24593,
	49157, 98317, 196613, 393241, 786433,
	1572869, 3145739, 6291469, 12582917, 25165843,
	50331653, 100663319, 201326611, 402653189, 805306457,
	1610612741, 3221225473, 4294967291
	};
	const unsigned long* first = __stl_prime_list;
	const unsigned long* last = __stl_prime_list +
		__stl_num_primes;
	const unsigned long* pos = lower_bound(first, last, n);
	return pos == last ? *(last - 1) : *pos;
}

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 Hash=HashFunc<K>>
class HashTable
{
	typedef HashNode<K,V> Node;
public:
	HashTable()
		:_tables(__stl_next_prime(0))
		,_n(0)
	{}
	~HashTable()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;

				delete cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
	}
	bool Insert(const pair<K, V> kv)
	{
		Hash hash;
		if (_n == _tables.size())
		{
			vector<Node*>NewTable(__stl_next_prime(_tables.size() + 1));
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					size_t hashi = hash(cur->_kv.first) % NewTable.size();
					cur->_next = NewTable[hashi];
					NewTable[hashi] = cur;

					cur = next;
				}
			}

			_tables.swap(NewTable);
		}
		size_t hashi = hash(kv.first) % _tables.size();
		Node* newnode = new Node(kv);
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;
		++_n;

		return true;
	}

	Node* Find(const K& key)
	{
		Hash hash;
		size_t hashi = hash(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)
	{
		Hash hash;
		size_t hashi = hash(key) % _tables.size();
		Node* prev = nullptr;
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (cur->_kv.first == key)
			{
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}

				delete cur;
				--_n;
				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}
private:
	vector<Node*> _tables;
	size_t _n=0;
};

四、链地址法

解决冲突的思路

开放定址法中所有的元素都放到哈希表里，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储一个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成一个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶。

下面演示 {19,30,5,36,13,20,21,12,24,96} 等这一组值映射到M=11的表中。

h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) =10，h(12) = 1,h(24) = 2,h(96) = 88

扩容 

开放定址法负载因子必须小于1，链地址法的负载因子就没有限制了，可以大于1。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低；stl中unordered_xxx的最大负载因子基本控制在1，大于1就扩容，我们下面实现也使用这个方式。

完整代码

#include<iostream>
#include<vector>
using namespace std;

template<class K>
struct FuncHash
{
	size_t operator()(const K& key)
	{
		return size_t key;
	}
};

template<>
struct FuncHash<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto ch : s)
		{
			hash += ch;
			hash * 131;
		}
		return hash;
	}
};

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)
	{}
};

inline unsigned long __stl_next_prime(unsigned long n)
{
	static const int __stl_num_primes = 28;
	static const unsigned long __stl_prime_list[__stl_num_primes] = {
		53, 97, 193, 389, 769,
		1543, 3079, 6151, 12289, 24593,
		49157, 98317, 196613, 393241, 786433,
		1572869, 3145739, 6291469, 12582917, 25165843,
		50331653, 100663319, 201326611, 402653189, 805306457,
		1610612741, 3221225473, 4294967291
	};
	const unsigned long* first = __stl_prime_list;
	const unsigned long* last = __stl_prime_list + __stl_num_primes;
	const unsigned long* pos = lower_bound(first, last, n);
	return pos == last ? *(last - 1) : *pos;
}

template<class K,class V,class Hash=FuncHash<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	HashTable()
		:_tables(__stl_next_prime(0))
		,_n(0)
	{}

	~HashTable()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}

			_tables[i] = nullptr;
		}
	}
	bool Insert(const pair<K, V>& kv)
	{
		if(Find(kv.first))
			return false;
		Hash hs;
		if (_n == _tables.size())
		{
			vector<Node*>NewTable(__stl_next_prime(_tables.size() + 1));
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					size_t hashi = cur->_kv.first % _tables.size();
					Node* next = cur->_next;
					cur->_next = _tables[hashi];
					_tables[hashi] = cur;

					cur = next;
				}

				_tables[i] = nullptr;
			}

			_tables.swap(NewTable);
		}
		size_t hashi = kv.first % _tables.size();
		Node* newnode = new Node(kv);
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;

		++_n;
		return true;
	}

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

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

		return false;
	}
private:
	vector<Node*> _tables;
	size_t _n;
};

 极端场景（了解一下）

如果极端场景下，某个桶特别长怎么办？其实我们可以考虑使用全域散列法，这样就不容易被针对
了。但是假设不是被针对了，用了全域散列法，但是偶然情况下，某个桶很长，查找效率很低怎么
办？这里在Java8的HashMap中当桶的长度超过一定阀值(8)时就把链表转换成红黑树。

本篇完，下篇见！

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

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

相关文章

Android-相对布局RelativeLayout

Android-相对布局RelativeLayout

相对布局在摆放子视图位置时&#xff0c;按照指定的参考系来摆放子视图的位置&#xff0c;默认以屏幕左上角(0,0)位置作为参考系摆放位置 了解一下接下来都会以代码的方式可视化出来 属性 可选值 说明 layout_alignParentTop true/false 是否让控件相对于父容器顶部对齐 …
阅读更多...
Intellij配置scala运行环境

Intellij配置scala运行环境

文章目录 Intellij配置scala运行环境下载地址安装插件设置sdk与scala scala项目创建安装可能出现的错误 Intellij配置scala运行环境 下载地址 在centos7上安装intellij https://www.jetbrains.com/idea/download/other.html解压后进入文件夹启动打开ide ./idea-IC-232.1033…
阅读更多...
【批量生成WORD和PDF文件】根据表格内容和模板文件批量创建word文件，一次性生成多个word文档和批量创建PDF文件

【批量生成WORD和PDF文件】根据表格内容和模板文件批量创建word文件，一次性生成多个word文档和批量创建PDF文件

如何按照Word模板和表格的数据快速制作5000个word文档 &#xff1f; 在与客户的合作的中需要创建大量的合同&#xff0c;这些合同的模板大概都是一致的&#xff0c;是不是每次我们都需要填充不一样的数据来完成&#xff1f; 今天用表格数据完成合同模板的填充&#xff0c;批量…
阅读更多...
深度网络结构中的梯度消失与爆炸原理分析

深度网络结构中的梯度消失与爆炸原理分析

原理 梯度消失的定义 在深度神经网络中&#xff0c;梯度消失是指在误差反向传播过程中&#xff0c;接近输入层的层次上梯度趋近于零的现象。这导致网络权重的更新非常缓慢&#xff0c;甚至停止&#xff0c;使得训练过程变得极其困难。主要发生在使用Sigmoid或Tanh等饱和激活函…
阅读更多...
请求go web后端接口 java安卓端播放视频

请求go web后端接口 java安卓端播放视频

前端代码 添加gradle依赖 implementation com.squareup.retrofit2:retrofit:2.9.0 implementation com.squareup.retrofit2:converter-gson:2.9.0 添加访问网络权限 <uses-permission android:name"android.permission.INTERNET" />允许http 请求请求 andro…
阅读更多...
乐凡信息智能安全管控方案：助力油气田行业安全管控多方位升级

乐凡信息智能安全管控方案：助力油气田行业安全管控多方位升级

我国油田地域广阔&#xff0c;分布着大量各种油井&#xff0c;油井开采设备的连续稳定运行是保证石油开采的首要条件。然而&#xff0c;由于油田多位于特殊地理环境中&#xff0c;因而实现油井之间的通信首要问题就是要克服地理环境所带来的限制&#xff0c;传统通信系统的建设…
阅读更多...
编辑， 抽成组件

编辑， 抽成组件

问题 错误思路&#xff1a; 1 dept不能修改&#xff0c; 用watch监听一下&#xff1a;赋值给新的变量进行修改&#xff0c; 问题&#xff1a; currentDept 发生改变&#xff0c; depth也发生了改变&#xff0c;因为是浅拷贝&#xff0c; 用了json.pase(json.stringify(value…
阅读更多...
＜项目代码＞YOLO Visdrone航拍目标识别＜目标检测＞

＜项目代码＞YOLO Visdrone航拍目标识别＜目标检测＞

项目代码下载链接 &#xff1c;项目代码&#xff1e;YOLO Visdrone航拍目标识别&#xff1c;目标检测&#xff1e;https://download.csdn.net/download/qq_53332949/90163918YOLOv8是一种单阶段&#xff08;one-stage&#xff09;检测算法&#xff0c;它将目标检测问题转化为一…
阅读更多...
如何从全局视角规划项目与战略决策（“精准接送”案例、技术架构设计与选型、业务逻辑及产品商业模式探讨）

如何从全局视角规划项目与战略决策（“精准接送”案例、技术架构设计与选型、业务逻辑及产品商业模式探讨）

文章目录 1. 引言2. 项目背景与需求分析2.1 业务背景&#xff08;5W分析法&#xff09;2.2 需求概述功能需求非功能需求 2.3 典型挑战 3. 技术架构设计与选型3.1 技术选型扩展表3.2 架构设计的深度思考3.2.1 核心架构原则3.2.2 实际架构实践 4. 业务逻辑及产品商业模式探讨4.1 …
阅读更多...
QT exe文件设置图标【终极解决方案！】

QT exe文件设置图标【终极解决方案！】

会报错&#xff1a;makefile error 1 将图片转换成ico文件&#xff0c;不能自己改后缀&#xff01;多试几个转换的网站&#xff0c;下面是我使的转换网站【成功了】 在线转换网址&#xff1a; https://onlineconvertfree.com/zh/convert/jpg/ 将图片放在.pro同级下 .pro和…
阅读更多...
JAVA：组合模式（Composite Pattern）的技术指南

JAVA：组合模式（Composite Pattern）的技术指南

1、简述 组合模式（Composite Pattern）是一种结构型设计模式，旨在将对象组合成树形结构以表示“部分-整体”的层次结构。它使客户端对单个对象和组合对象的使用具有一致性。 设计模式样例：https://gitee.com/lhdxhl/design-pattern-example.git 2、什么是组合模式 组合模式…
阅读更多...
CTFHUB 历年真题 afr-1

CTFHUB 历年真题 afr-1

发现传参为 ?phello&#xff0c;尝试 ?pflag 发现都是 no 尝试假设它是个PHP文件&#xff0c;利用php伪协议 ?pphp://filter/readconvert.base64-encode/resourceflag 得到 base64 编码再解码发现了本题的 flag n1book{afr_1_solved}
阅读更多...
共创共建！葡萄城 SpreadJS 完成 HarmonyOS NEXT 操作系统兼容认证

共创共建！葡萄城 SpreadJS 完成 HarmonyOS NEXT 操作系统兼容认证

最新技术资源&#xff08;建议收藏&#xff09; https://www.grapecity.com.cn/resources/ 近日&#xff0c;华为“企业工作必备应用鸿蒙化论坛”在北京圆满落幕&#xff0c;论坛汇聚了众多行业精英和合作伙伴&#xff0c;聚焦讨论企业数字化转型与原生鸿蒙生态融合等话题。葡萄…
阅读更多...
Android学习(二)-Kotlin编程语言学习

Android学习(二)-Kotlin编程语言学习

接上篇文章&#xff0c;我们写如下语法&#xff0c;重新赋值&#xff0c;你会发现报错了&#xff0c;是因为val关键字等同于Java中的final&#xff0c;是无法被改变的&#xff0c;如果想更改数值&#xff0c;换成var即可 函数学习 函数的基本概念 函数是用于封装一段代码的载…
阅读更多...
【JavaEE进阶】第一个Spring Boot程序

【JavaEE进阶】第一个Spring Boot程序

目录 &#x1f334;安装插件 &#x1f384;Spring Boot介绍 &#x1f333;Spring Boot项目创建 &#x1f6a9;创建Spring Boot项目 &#x1f3c0;jar 包下载不下来问题 &#x1f6a9;启动项目 &#x1f332;目录介绍 &#x1f6a9;src文件 &#x1f6a9;target文件 &…
阅读更多...
Oracle 中间件 Webcenter Portal服务器环境搭建

Oracle 中间件 Webcenter Portal服务器环境搭建

环境信息 服务器基本信息 如下表&#xff0c;本次安装总共使用2台服务器&#xff0c;具体信息如下&#xff1a; Webcenter1服务器 归类 SOA服务器 Ip Address 172.xx.xx.xx.xx HostName wcc01.xxxxxx.com Alias wccprd01 Webcenter2服务器 归类 OSB服务器 Ip Addr…
阅读更多...
浅谈文生图Stable Diffusion（SD）相关模型基础

浅谈文生图Stable Diffusion（SD）相关模型基础

1.U-Net模型基础 1.基础概念 UNet模型是一种基于卷积神经网络的图像分割算法&#xff0c;它采用了U型的网络结构&#xff0c;由编码器&#xff08;下采样路径&#xff09;和解码器&#xff08;上采样路径&#xff09;两部分组成。 编码器负责提取输入图像的特征&#xff0c;…
阅读更多...
【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析

【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析

目录 一、前言 二、Spring Boot 简介 三、Spring Boot 核心模块 四、Spring Boot 项目实战&#xff1a;构建一个简单的 RESTful API 1. 创建 Spring Boot 项目 2. 配置数据库 3. 创建实体类 4. 创建 JPA 仓库接口 5. 创建服务层 6. 创建控制器层 7. 测试 API 8. 运…
阅读更多...
css 动画实现从中间到两边亮度逐渐变暗的流水灯效果

css 动画实现从中间到两边亮度逐渐变暗的流水灯效果

先看效果&#xff1a; 快结束效果 随着离中心点距离逐渐边远&#xff0c;亮度逐渐变暗 完整的视线代码如下&#xff1a; <template><div class"container"><div class"runner bottom to-right"></div><div class"runner …
阅读更多...
k8s迁移——岁月云实战笔记

k8s迁移——岁月云实战笔记

新系统使用rockylinux9.5&#xff0c;旧系统虚拟机装的是centos7 1 目标服务器 1.1 禁止swap swapoff -a vi /etc/fstab #/dev/mapper/rl-swap none swap defaults 0 0 #执行&#xff0c;swap一行都是0 free -h 1.2 关闭防火墙 只是为了减…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023