【C++】哈希算法

news2024/11/29 4:38:11

目录

 

1.哈希映射

1.1哈希的概念

 1.2哈希冲突

1.3哈希函数 

 1.31直接定值法

1.32除留余数法 

 2.解决哈希冲突

2.1闭散列法

2.11线性探测

2.12二次探测 

3代码实现 

3.1状态：

3.2创建哈希节点类

3.21哈希表扩容：

3.3数据插入

3.4查找与删除

 3.5仿函数 

完整cpp表

4.开散列哈希桶

4.1概念

4.2仿函数 

4.3哈希桶结点构建 

4.4哈希桶的查找和删除

4.5哈希桶的插入 

1.哈希映射

1.1哈希的概念

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

当向该结构中：

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)。
unordered_map和unordered_set的底层就是哈希来实现的，它是无序的。

  • Hash（key）=key%capacity。

聪明的小伙伴已经找到矛盾了，如果说再添加一个数据5，那他存那？ 

 1.2哈希冲突

对于两个数据元素的关键字 k_{i} 和 k_j{} (i != j)，有 k_{i} != k_j{} ，但有：Hash(k_{i}) == Hash(k_j{})，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

所以这种方式建立起来的映射就十分的不合理，所以我们要改进。

哈希设计的原则：

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

1.3哈希函数 

 1.31直接定值法

取关键字的某个线性函数为散列地址：Hash(key)= A*key + B

 优点：简单，速度快，节省空间，查找key O(1)的时间复杂度

 缺点：当数据范围大时会浪费空间，不能处理浮点数，字符串数据

 使用场景：适用于整数，数据范围比较集中

 例如计数排序，统计字符串中出现的用26个英文字符统计，给数组分配26个空间，遍历到的字符是谁，就把相应的元素值++

1.32除留余数法 

把数据映射到有限的空间里面。设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m)，将key转换成哈希地址。

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

看1.1节的例子

 解决哈希冲突最常用的方法是闭散列和开散列。

 2.解决哈希冲突

2.1闭散列法

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

但是咋去找下一个空位置才是最关键的？

2.11线性探测

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

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

给每个位置一个标记，用空、存在、删除3种状态来区分。

  1. 负载因子 = 存储的有效数据个数/空间的大小 。
  2. 负载因子越大，冲突的概率越高，增删查改效率越低。
  3. 负载因子越小，冲突的概率越低，增删查改的效率越高，但是空间利用率低，浪费多。 
  4. 负载因子 <1，就能保证发生哈希冲突时一定能找到空位置。

线性探测的优缺点:

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

2.12二次探测 

二次探测改进了一些线性探测，但是也就那样，这里我就不给太多画面了。

所谓的二次探测我们可以理解为飞跃式，线性是一个一个找空位置，二次就是跳着找。

方法：hash(key) + i^2

hash(11)=11%10+0*2=1,但是1的位置被占了，所以变成hash(11)+1*2,如果这个位置是空的就放进去，不是的话，i继续加。

3代码实现 

3.1状态：

状态：这里需要三种状态：空，已占用，已删除

如果只用有/没有来代表状态，那删除一个数据后，这个位置就是空的，那就不会再遍历了，但是它后面还有数据的话就存在问题了，所以我们用已删除这个状态来表示的话，还可以遍历后面的数据。

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

namespace CloseHash
{
	enum State
	{
		EMPTY,   //0 空
		EXIST,   //1  存在
		DELETE,   // 2 已删除
	};
}

3.2创建哈希节点类

template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;//数据
		State _state = State::EMPTY;//状态  --空
	};
	template<class K, class V>//添加仿函数便于把其他类型的数据转换为整型数据
	class HashTable
	{

	public:
		//相关功能的实现……

	private:
		vector<HashData<K, V>> _table;//哈希表
		size_t _n = 0;//存储哈希表中有效数据的个数
	};

  • 查找：当数据是1时，直接映射到下标1处，此时该位置的状态是EXIST，数据是11时，映射到下标1处，但是已经有1了所以++往后找空位置找到后状态更新为EXIST。
  • 删除：删除1，找11，当删除1后，状态更新为DELETE，查找11时下标发现状态是DELETE时会继续往后移动，然后找到11.

3.21哈希表扩容：

当插入的数据较多，而哈希表较短时，就要考虑到扩容，但是哈希的扩容不简单，因为一扩容，下标就变了，那很多数据的映射后的位置就变了。

现在的11在下标11处，就不在2处了。 

所以我们在上面提到了负载因子： 填入表中的元素个数 / 散列表的长度

由于散列表的长度一定，所以负载因子和表中的元素个数成正比。元素个数越多，哈希冲突越大，所以我们一般将负载因子定在0.7~0.8，在代码中我们就定在0.7。

插入时我们再介绍。

3.3数据插入

插入的详细步骤：

  • 去除重复：
  1. 插入的值可能 已经存在，所以用用Find先进行查找
  2. 找到就返回false,没找到在插入。
  • 空间扩容：
  1. 如果表是空的就给10个空间，否则扩大2倍。
  2. 建立一个新哈希表，把旧表的值插入到新表
  • 探测找位
  1. 如果位置的状态是EXIST,继续往后移
  2. 找到空位置后，插入，状态变为存在，_n++。
//查找
	bool Insert(const pair<K, V>& kv)
	{
		
		size_t hashi = kv.first % _tables.size();    //1.遇到空就停止了
		//线性探测
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}

在1.0版本中我注意两个细节：

  • hashi为啥要模size而不是capacity?

计算机开辟了20个空间，只存储10个数据，但是只能让计算机在前十个空间存，要不一旦用空的空间，遍历时遇到后就不在往后进行了。所以开的空间一般和数据个数一致。

  • while循环中为啥要加一步hashi%=_table.size()?

比如我们开了20个空间，下标16以后都存满了但是前面还有位置，但是我们存一个37，那他就一直找位置，直到找到19，然后就出这个哈希表了，所以要让他返回到表上再到下标靠前的位置去找。

接下来就要开辟空间了。但是这个可不简单。

当插入的数据较多，而哈希表较短时，就要考虑到扩容，但是哈希的扩容不简单，因为一扩容，下标就变了，那很多数据的映射后的位置就变了。

现在的11在下标11处，就不在2处了。 

所以我们在上面提到了负载因子： 填入表中的元素个数 / 散列表的长度

由于散列表的长度一定，所以负载因子和表中的元素个数成正比。元素个数越多，哈希冲突越大，所以我们一般将负载因子定在0.7~0.8，在代码中我们就定在0.7。

在这里我们就要重新建一个哈希表。

//查找
	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);  //扩容后用一个新表
			//遍历旧表，把旧表每个存在的元素插入newHT
			for (auto& e : _tables)
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}
			newHT._tables.swap(_tables);//建立映射关系后交换

		}
		size_t hashi = kv.first % _tables.size();    //1.遇到空就停止了
		//线性探测
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}

如果哈希表中已经有插入的值时，我们就要去除冗杂，用find函数。

3.4查找与删除

查找的大致思路和插入的很接近，这里就不在重复了。

//查找
	HashData<K, V>* Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return nullptr;
		}
		size_t hashi = key % _tables.size();
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];   //返回的是地址
			}
			hashi++;
			hashi %= _tables.size();
		}
		return nullptr;
	}
	//删除
	bool Erase(const K& key)
	{
		HashData<K, V>* ret=Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
		}
		else
		{
			return false;
		}
	}

删除时，我们直接把要删除的数据状态改成DELETE就行了，甚至内部的数据都不用删除。

 3.5仿函数 

这里的取模用的都是整数，那如果数据是浮点型？更甚至是字符串怎么搞？所依我们就要用到仿函数来进行类型转换。

//利用仿函数将数据类型转换为整型
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
//模板的特化
template<>
struct HashFunc<string>  //如果是字符串，直接调用特化模板
{
	size_t operator()(const string& key)
	{
		
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii码值累计加起来
		}
		return hash;
	}
};

完整cpp表

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

enum State
{
	EMPTY,   //0 空
	EXIST,   //1  存在
	DELETE,   // 2 已删除
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;//数据
	State _state = State::EMPTY;//状态  --空
};
//利用仿函数将数据类型转换为整型
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
//模板的特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)  //字符串直接使用
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii码值累计加起来
		}
		return hash;
	}
};
template<class K, class V,class Hash = HashFunc<K>>
class HashTable
{

public:
	//插入
	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);  //扩容后用一个新表
			//遍历旧表，把旧表每个存在的元素插入newHT
			for (auto& e : _tables)
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}
			newHT._tables.swap(_tables);//建立映射关系后交换

		}
		Hash hf;
		size_t start = hf(kv.first);//取出键值对的key，并且避免了负数的情况，借用仿函数确保是整型数据
		start %= _tables.size();
		size_t hashi = start;
		size_t i = 1;
		//1.遇到空就停止了
		//线性探测
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}
	//查找
	HashData<K, V>* Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return nullptr;
		}
		Hash hf;
		size_t start = hf(key);//通过仿函数把其它类型数据转为整型数据
		start %= _tables.size();
		size_t hashi = start;
		size_t i = 1;
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];   //返回的是地址
			}
			hashi++;
			hashi %= _tables.size();
		}
		return nullptr;
	}
	//删除
	bool Erase(const K& key)
	{
		HashData<K, V>* ret=Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
		}
		else
		{
			return false;
		}
	}
private:
	vector<HashData<K, V>> _tables;//哈希表
	size_t _n = 0;//存储哈希表中有效数据的个数
};


void testHash1()
{
	int a[] = { 1,11,4,15,26,7 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.Insert(make_pair(e, e));
	}
}

4.开散列哈希桶

4.1概念

开散列也叫拉链法：先对所有key用散列函数计算散列地址，把有相同地址的key每个key都作为一个桶，通过单链表链接在哈希表中。

此时的表里面存储一个链表指针，就是把冲突的数据通过链表的形式挂起来。

它的算法公式：hash(key)=key%capacity

 这里的插入可以是头插也可以是尾插，插入时是无序的。

 也就是说哈希桶的根本是一个指针数组，哈希桶的每一个位置存的都是一个链表指针。

这个指针数组里的每一个元素都是结点指针，并且头插的效率比较高。

4.2仿函数 

这次我们先弄模板来将其他类型转换为size_t。

namespace OpenHash
{
	template<class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	// 特化
	template<>
	struct Hash < string >
	{
		size_t operator()(const string& s)
		{
			// BKDR Hash
			size_t value = 0;
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}

			return value;
		}
	};
}

4.3哈希桶结点构建 

因为是指针数组，所以结点中的成员变量多了一个指向下一个桶的指针。

//结点类
	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:
		//相关功能的实现……
	private:
		//指针数组
		vector<Node*> _tables;
		size_t _n = 0;//记录有效数据的个数
	};

4.4哈希桶的查找和删除

这里的查找\删除操作和上面的如出一辙，但是哈希桶的存储是链表的形式，所以会和链表的相关操作很接近。

//查找
		Node* Find(const K& key)
		{
			//防止后续除0错误
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			//构建仿函数
			HashFunc hf;
			//找到对应的映射下标位置
			size_t hashi = hf(key);
			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			//在此位置的链表中进行遍历查找
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//找到了
					return cur;
				}
				cur = cur->_next;
			}
			//遍历结束，没有找到，返回nullptr
			return nullptr;
		}
		//删除
		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//1.头删
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else    //中间位置删除
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

4.5哈希桶的插入 

  • 去除重复：
  1. 插入的值可能 已经存在，所以用用Find先进行查找
  2. 找到就返回false,没找到再进行插入。
  • 空间扩容：
  1. 如果负载因子==1就进行扩容。
  2. 建立一个新哈希表，把旧表的值插入到新表。
  3. 再把新表交换到旧表那里。

但是在把旧表映射到新表时要释放掉旧表，vector类型会自动调用析构函数，然而存储的数据是Node*类型的，是内置类型，不会自动释放，结果就是哈希表释放了但是表中存的数据没释放，所以我们要手写一个析构函数。

  • 头插操作
  1. 根仿函数找到合适映射位置
  2. 进行头插操作并更新桶内数据个数。

所以我们首先写一个析构函数：

//析构函数
		~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)
		{
			//1、去除重复
			if (Find(kv.first))
			{
				return false;
			}
			//2、负载因子 == 1就扩容
			if (_tables.size() == _n)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTable;
				newTable.resize(newSize, nullptr);
				for (size_t i = 0; i < _tables.size(); i++)//遍历旧表
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hf(cur->_kv.first) % newSize;//确认映射到新表的位置
						//头插
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				newTable.swap(_tables);
			}
			//3、头插
			//构建仿函数，把数据类型转为整型，便于后续建立映射关系
			HashFunc hf;
			size_t hashi = hf(kv.first);
			hashi %= _tables.size();
			//头插到对应的桶即可
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}

C++ 进阶: 本仓库存放一些较难C++代码https://gitee.com/j-jun-jie/c---advanced.git

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

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

相关文章

数据可视化之设计经验分享：轻松三步教你学会制作数据可视化大屏思路

数据可视化之设计经验分享：轻松三步教你学会制作数据可视化大屏思路

当看到屏幕上一个个炫酷&#xff0c;具有科技感的数据大屏时&#xff0c;很多人都会好奇这是怎么做出来的。自己在制作大屏时明明按着需求做了&#xff0c;可是做出来后总是觉得画面不好看&#xff0c;不够炫&#xff0c;感觉很糟糕。 那要如何才能设计那样的数据可视化大屏呢…
阅读更多...
JS 的新一代日期/时间 API Temporal

JS 的新一代日期/时间 API Temporal

众所周知&#xff0c;JS的Date是出了名的难用&#xff0c;一直以来我们都在使用momentjs&#xff0c;dayjs等第三方库来处理日期和时间格式&#xff0c;于是 TC39 组织开始了对 Date 的升级改造&#xff0c;他们找到了 moment.js 库的作者&#xff0c;Maggie &#xff0c;由她来…
阅读更多...
【深度学习】实验5答案：滴滴出行-交通场景目标检测

【深度学习】实验5答案：滴滴出行-交通场景目标检测

DL_class 学堂在线《深度学习》实验课代码报告&#xff08;其中实验1和实验6有配套PPT&#xff09;&#xff0c;授课老师为胡晓林老师。课程链接&#xff1a;https://www.xuetangx.com/training/DP080910033751/619488?channeli.area.manual_search。 持续更新中。 所有代码…
阅读更多...
代码随想录刷题| 01背包理论基础 LeetCode 416. 分割等和子集

代码随想录刷题| 01背包理论基础 LeetCode 416. 分割等和子集

目录 01背包理论基础 二维dp数组 1、确定dp数组以及下标的含义 2、确定递推公式 3、dp数组如何初始化 4、确定遍历顺序 5、打印dp数组 最终代码 一维dp数组 1、确定dp数组的定义 2、确定递推公式 3、初始化dp数组 4、遍历顺序 5、打印dp数组 最终代码 416. 分割…
阅读更多...
一次搞懂SpringBoot核心原理：自动配置、事件驱动、Condition

一次搞懂SpringBoot核心原理：自动配置、事件驱动、Condition

前言 SpringBoot是Spring的包装&#xff0c;通过自动配置使得SpringBoot可以做到开箱即用&#xff0c;上手成本非常低&#xff0c;但是学习其实现原理的成本大大增加&#xff0c;需要先了解熟悉Spring原理。如果还不清楚Spring原理的&#xff0c;可以先查看博主之前的文章&…
阅读更多...
Vue实现简易购物车功能

Vue实现简易购物车功能

用Vue写一个列表案例&#xff0c;页面布局什么的dom&#xff0c;不需要自己事先全部排好&#xff0c;而是通过li遍历&#xff0c;把数据遍历出来&#xff1b;先定义好div标签&#xff0c;li根据数组的长度datalist进行遍历&#xff0c;图片的链接要用“&#xff1a;”&#xff…
阅读更多...
算法设计与分析 SCAU8597 石子划分问题

算法设计与分析 SCAU8597 石子划分问题

8597 石子划分问题 时间限制:1000MS 代码长度限制:10KB 提交次数:0 通过次数:0 题型: 编程题 语言: G;GCC;VC;JAVA Description 给定n个石子&#xff0c;其重量分别为a1,a2,a3,…,an。 要求将其划分为m份&#xff0c;每一份的划分费用定义为这份石子中最大重量与最小重量差…
阅读更多...
nRF52832闪存FDS使用(SDK17.1.0)

nRF52832闪存FDS使用(SDK17.1.0)

陈拓 2022/10/29-2022/11/22 1. 简介 对于Nordic芯片内部FLASH存储管理有两种方式&#xff0c;FS (Flash Storage)和FDS (Flash Data Storage) 。FS是FDS的底层实现&#xff0c;FDS是对FS的封装&#xff0c;使用更容易。 Flash Data Storage&#xff08;FDS&#xff09;模块是…
阅读更多...
容器与容器编排系统

容器与容器编排系统

Docker公司发明的「容器镜像」技术&#xff0c;创造性地解决了应用打包的难题。改变了一大批诸如容器编排、服务网格和云原生等技术&#xff0c;深刻影响了云计算领域的技术方向。 一、Docker 容器技术 概括起来&#xff0c;Docker 容器技术有3个核心概念容器、镜像和镜像仓库…
阅读更多...
当3A射击游戏遇上Play to Earn，暴躁兔带你了解MetalCore

当3A射击游戏遇上Play to Earn，暴躁兔带你了解MetalCore

MetalCore是一款具有机甲风格的战斗射击类的Play to Earn & Free to Play游戏&#xff0c;暴躁兔对这款游戏之前也有做过分析&#xff0c;MetalCore在近期启动了alpha开放世界测试&#xff0c;之前有NFT的玩家获得key code之后可以在PC端下载后进行体验。alpha阶段在10月20…
阅读更多...
如何使IOT2050成为PN设备

如何使IOT2050成为PN设备

Profinet Driver&#xff08;PNDriver&#xff09;从V2.3开始支持IO设备(IOD)功能&#xff0c;支持通用网络接口和Linux操作系统&#xff0c;最小支持2ms的通讯周期。本文介绍如何编译PNDriver并运行在IOT2050上。 1. 编译PNDriver 因为PNDriver只支持32位模式&#xff0c;因…
阅读更多...
TiDB ——TiKV

TiDB ——TiKV

TiDB ——TiKV TiKV持久化 TiKV架构和作用TiKV数据持久化和读取TiKV如何提供MVCC和分布式事务支持TiKV基于Raft算法的分布式一致性TiKV的coprocessor TiKV架构和作用 数据持久化分布式一致性MVCC分步式事务Coprocessor RocksDB 单机持久化引擎&#xff0c;单机key-value的…
阅读更多...
L2十档行情API接口的开发原理是什么？

L2十档行情API接口的开发原理是什么？

L2十档行情API接口的开发原理不知道大家有没有了解过&#xff0c;其实在现实的股市量化交易中&#xff0c;就有不少的投资者也在思考这个问题&#xff0c;并且也有的部分交易者会选择自己开发来使用&#xff0c;不仅支持A股所有的股票数据&#xff0c;也能对期货、外汇、黄金等…
阅读更多...
个人项目-部署手册

个人项目-部署手册

前言 一、RDS和ECS购买与配置 https://www.aliyun.com/?spm5176.12818093.top-nav.dlogo.3be916d0u0Ncp9 购买RDS(MYSQL)和ECS(规格族&#xff1a;突发性能实例 t6 )的时候尽量选择一个大区》如&#xff1a;华东&#xff08;杭州&#xff09;配置不需要太高(够自己使用就行了…
阅读更多...
干货分享 | B站SLO由失败转成功，B站SRE做对了什么？

干货分享 | B站SLO由失败转成功，B站SRE做对了什么？

最近几年&#xff0c;Google SRE在国内非常流行。 Google SRE方法论中提出了SLO是SRE实践的核心&#xff0c;SLO为服务可靠性设定了一个目标级别&#xff0c;它是量化线上质量的关键因素&#xff0c;它是用来回答一个服务到底“什么时候叫做挂了”的根本依据&#xff0c;也是可…
阅读更多...
Python网络爬虫入门篇

Python网络爬虫入门篇

1. 预备知识 学习者需要预先掌握Python的数字类型、字符串类型、分支、循环、函数、列表类型、字典类型、文件和第三方库使用等概念和编程方法。 2. Python爬虫基本流程 a. 发送请求 使用http库向目标站点发起请求&#xff0c;即发送一个Request&#xff0c;Request包含&am…
阅读更多...
xxl-job 执行成功,但是报“任务结果丢失，标记失败“错误

xxl-job 执行成功,但是报“任务结果丢失，标记失败“错误

问题1:使用xxl定时更新数据,发现执行结果是失败的 打开日志查看,发现没报错,结果是200 打开备注,上面写着"结果丢失". 再仔细对比下,发现外面日志列表中的执行时间是00:20:18;而日志记录中的最后时间是00:39:32;也就是说线程还没执行完,就先报结果错误了. 对比日志时…
阅读更多...
[附源码]Python计算机毕业设计宠物寄养管理系统

[附源码]Python计算机毕业设计宠物寄养管理系统

项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等等。 环境需要 1.运行环境&#xff1a;最好是python3.7.7&#xff0c;…
阅读更多...
Jmeter压力测试教程(上)

Jmeter压力测试教程(上)

JMeter压力测试一、 简介1.1优点1.2缺点二、安装2.1下载2.2解决中文乱码问题2.5配置环境变量2.4启动入门案例三、线程组相关3.1 创建多个线程组3.2 并发和顺序执行3.3 两个特殊的线程组&#xff08;setUp/tearDown&#xff09;线程细节设置默认http请求新增接口信息头管理器四、…
阅读更多...
SAP ADM100-1.2之系统登录过程（ABAP）

SAP ADM100-1.2之系统登录过程（ABAP）

1、SAP登录过程 为了在前端最终用户和SAP系统实例之间创建连接，sapgui.exe程序需要启动参数。参数字符串是由saplogon .exe程序使用为登录选择的SAP GUI的信息创建。 SAP登录信息有以下两个来源：SAP Logon的配置文件，以及对所选系统的消息服务器的直接请求（下图中的步骤1和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023