【C++】哈希

一、unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N log2​N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。

最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器：unordered_map、unordered_set、unordered_multimap和unordered_multiset，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，接口使用可以查看文档。

二、哈希

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

1. 哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O ( N ) O(N) O(N)，平衡树时间复杂度为树的高度，即O( l o g 2 N log_2 N log2​N)。

搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数（hashFunc）使元素的存储位置与它的关键码之间能够建立 一 一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

  • 插入元素
    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

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

该方式即为哈希(散列) 方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合 1 ， 17 ， 6 ， 24 ， 5 ， 9 {1，17，6，24，5，9} 1，17，6，24，5，9
哈希函数设置为： h a s h ( k e y ) = k e y % c a p a c i t y ; hash(key) = key \% capacity; hash(key)=key%capacity;
capacity为存储元素底层空间总的大小。

在这里插入图片描述

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

问题：按照上述哈希方式，向集合中插入元素14，会出现什么问题？

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​)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突 或 哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

3. 哈希函数

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

哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有 m m m个地址时，其值域必须在 0 0 0到 m − 1 m-1 m−1之间

  • 哈希函数计算出来的地址能均匀分布在整个空间中

  • 哈希函数应该比较简单

常见哈希函数：

  1. 直接定址法–(常用)
    取关键字的某个线性函数为散列地址： H a s h ( K e y ) = A ∗ K e y + B Hash(Key) = A*Key + B Hash(Key)=A∗Key+B
    优点：简单、均匀
    缺点：需要事先知道关键字的分布情况
    使用场景：适合查找比较小且连续的情况

  2. 除留余数法–(常用)
    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数： H a s h ( k e y ) = k e y % p ( p < = m ) Hash(key) = key\% p(p<=m) Hash(key)=key%p(p<=m)，将关键码转换成哈希地址

  3. 平方取中法–(了解)
    假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址。
    平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

  4. 折叠法–(了解)
    折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
    折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

  5. 随机数法–(了解)
    选择一个随机函数，取关键字的随机函数值为它的哈希地址，即 H ( k e y ) = r a n d o m ( k e y ) H(key) = random(key) H(key)=random(key)，其中 random为随机数函数。 通常应用于关键字长度不等时采用此法

  6. 数学分析法–(了解)
    设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：

在这里插入图片描述

数字分析法通常适合处理关键字位数比较大的情况，适用于事先知道关键字的分布且关键字的若干位分布较均匀的情况

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

4. 哈希冲突解决

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

4.1 闭散列

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

  1. 线性探测
    比如1中的场景，现在需要插入元素14，先通过哈希函数计算哈希地址，hashAddr为4， 因此14理论上应该插在该位置，但是该位置已经放了值为24的元素，即发生哈希冲突。
    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
    • 插入
      通过哈希函数获取待插入元素在哈希表中的位置
      如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
    • 删除
      采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素，会影响其他元素的搜索。比如删除元素24，如果直接删除掉，14查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
  • 线性探测的实现：
// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State
{
	EMPTY,
	EXIST,
	DELETE,
};
template<class K, class V>
struct HashData
{
	std::pair<K, V> _kv;
	State _state = EMPTY;
};
template<class K, class V>
class HashTable
{
	typedef HashData<K, V> Data;
public:
	bool Insert(const pair<K, V>& kv)
	{
		// 如果找到不插入，直接返回fasle
		if (Find(kv.first))
			return false;
			
		size_t hashi = kv.first % _tables.size();
		while (_tables[hashi]._state == EXIST)
		{
			++hashi;// 线性探测：一个个往后找空位
			hashi %= _tables.size();
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		return true;
	}
	Data* Find(const K& key)
	{}
private:
	std::vector<Data> _tables;
	size_t _n;// 哈希表中存储的有效数据的个数
};

上面的insert的实现是有问题的：

  1. _tables的初始大小是0，取模肯定是错误的
    可以给一个初始大小：
HashTable()
	:_n(0)
{
	_tables.resize(10);
}
  1. 当_tables接近满时冲突的概率是非常大的

所以要扩容。如何扩容？

散列表的载荷因子/负载因子定义为: α α α =填入表中的元素个数 / 散列表的长度

α α α是散列表装满程度的标志因子。
由于表长是定值， α α α与“填入表中的元素个数”成正比，所以， α α α越大，表明填入表中的元素越多，产生冲突的可能性就越大; 反之， α α α越小，表明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子 α α α的函数，只是不同处理冲突的方法有不同的函数。

对于开放定址法，载荷因子是特别重要的因素，应严格限制在0.7-0.8以下。超过0.8，查表时的CPU缓存不命中（cache missing）按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了载荷因子为0.75，超过此值将resize散列表。

库中也有关于负载因子的接口（库中是开散列）：

在这里插入图片描述

在这里插入图片描述

  • 扩容代码：
void CheckCapacity()
{
	// 这种方式是扩不了容的，正整数除要么为0，要么>= 1
	//if (_n / _tables.size() >= 0.7)	
	// 同样这里如果_tables的初始大小为0，会有除0错误
	if (_n * 10 / _tables.size() >= 7)
	{
		// 方式1：旧表数据，重新计算，映射到新表
		/*vector<Data> newTable;  --> vector
		newTable.resize(_tables.size() * 2);
		for (auto& e : _tables)
		{
			if (e._state == EXIST)
			{
				// 插入比方式2麻烦: 计算新的哈希地址，插入newTable
			}
		}
		// 最后交换vector
		_tables.swap(newTable);
		*/

		// 方式2：
		HashTable<K, V> newHT;  // --> HashTable
		// HashTable中的vector开好2倍空间
		newHT._tables.resize(_tables.size() * 2);
		for (auto& e : _tables)
		{
			// 旧表中存在的数据插入到新表
			if (e._state == EXIST)
			{
				// 新表调用Insert不会扩容，因为提前开好了2倍空间
				// 复用Insert
				newHT.Insert(e._kv);
			}
		}
		// 最后交换vector
		_tables.swap(newHT._tables);
	}
}
  • 删除和查找
bool Erase(const K& key)
{
	Data* ret = Find(key);
	if (ret)
	{
		ret->_state = DELETE;
		--_n;
		return true;
	}
	else
	{
		return false;
	}
}
Data* Find(const K& key)
{
	size_t hashi = key % _tables.size();
	while (_tables[hashi]._state != EMPTY)
	{
		// 找到的条件：
		// 1. 状态是EXIST：注意 _state != EMPTY可以是DELETE
		// 2. key要相等：因为位置可能被其他冲突值占用了
		if (_tables[hashi]._state == EXIST
			&& _tables[hashi]._kv.first == key)
		{
			return &_tables[hashi];
		}

		++hashi;
		hashi %= _tables.size();
	}

	return nullptr;
}

前面的实现中没有考虑到取模只能对整数进行取模。如果key是字符串或浮点数类型就不能直接取模了。我们可以写一个函数将字符串或浮点数映射成一 一对应的整数，更好的方式是传一个仿函数，这样自定义类型只要提供这个仿函数也可以用哈希表存储。

在这里插入图片描述

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

// 模板特化
template<>
struct HashFunc<std::string>
{
	size_t operator()(const std::string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			// *131冲突概率更小
			hash *= 131;// // 31 131 1313 13131 131313
			hash += ch;
		}
		return hash;
	}
};

在对key取模操作之前先用仿函数获得一个映射值，再映射哈希地址，这里有两层映射关系。

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
	// ……
public:
	bool Insert(const std::pair<K, V>& kv)
	{
		// ……
		Hash hf;
		size_t hashi = hf(kv.first) % _tables.size();
		// ……
	}
	Data* Find(const K& key)
	{
		size_t hashi = Hash()(key) % _tables.size();
		//size_t hashi = key % _tables.size();
		// ……
	}
};

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

  1. 二次探测
    线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：
    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​是通过散列函数 H a s h ( x ) Hash(x) Hash(x)对元素的关键码 key 进行计算得到的位置，m是表 的大小。对于1中的场景，现在需要插入元素14，产生冲突，使用解决后的情况为：

在这里插入图片描述

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。

因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出 必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

4.2 开散列

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

在这里插入图片描述

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

  1. 开散列的实现

在哈希表实现中，哈希表的大小经常被设计为质数。下面代码中的stl_prime_list保存了一组质数，用于在哈希表初始化和扩容时选择合适的大小，以便更好地分散元素的位置，减少哈希冲突，提高哈希表的性能。

// 开散列
namespace bucketHash
{
	template<class T>
	struct HashNode// 单链表节点
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};
	template<class K, class T, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		typedef HashNode<T> Node;
		HashTable()
			:_n(0)
		{
			//_tables.resize(10);
			// 初始化成质数
			_tables.resize(__stl_next_prime(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;
			}
		}
	private:
		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
			};
			// 当然这里也可以用二分查找
			for (int i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];
				}
			}
			return __stl_prime_list[__stl_num_primes - 1];
		}
		std::vector<Node*> _tables;
		size_t _n = 0;
	};
};
  • 开散列如何扩容呢？

下面的扩容代码有什么缺点吗？

bool Insert(const std::pair<K, V>& kv)
{
	if (Find(kv.first))
		return false;
	// 负载因子控制在1，超过就扩容 
	// 库中的负载因子控制在1 max_load_factor可查看负载因子
	if (_tables.size() == _n)
	{
		HashTable<K, V, Hash> newHT;
		newHT._tables.resize(_tables.size() * 2, nullptr);
		// 注意不要将整条链表直接放到新表
		// 首先链表中每个节点的位置可能会发生变化
		// 其次会重复析构
		// 正确的做法是将节点一个个插入新表
		for (auto cur : _tables)
		{
			while (cur)
			{
				newHT.Insert(cur->_kv);// 新表插入不会扩容
				cur = cur->_next;
			}
		}
		// 交换表中的数组
		_tables.swap(newHT._tables);
	}

	size_t hashi = Hash()(kv.first) % _tables.size();
	// 头插
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;

	return true;
}

在我们将旧表数据插入到新表时，每次会重新new一个值相同的节点出来（这一步重复new节点）；交换之后newHT中是旧表的数据，newHT是局部变量，出作用域后会调用析构将旧表中的所有节点析构。这个过程中我们做了重复的工作，那可不可以不删掉旧表中的节点？答案是可以的：

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

	// 负载因子控制在1，超过就扩容 --> 库中的实现 max_load_factor可查看负载因子
	if (_tables.size() == _n)
	{
		std::vector<Node*> newTables;
		//newTables.resize(2 * _tables.size(), nullptr);
		newTables.resize(__stl_next_prime(_tables.size()), nullptr);
		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) % newTables.size();
				// 头插到新表 -- 旧表节点没有被释放
				cur->_next = newTables[hashi];
				newTables[hashi] = cur;
				cur = next;
			}
			// 旧表位置置空，防止交换之后newTables析构出错
			_tables[i] = nullptr;
		}
		// 交换数组
		_tables.swap(newTables);
	}

	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)
{
	size_t hashi = Hash()(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)
{
	size_t hashi = Hash()(key) % _tables.size();
	Node* prev = nullptr;
	Node* cur = _tables[hashi];
	// 单链表删除
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			// 首结点删除特殊处理
			if (cur == _tables[hashi])
			{
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;// 链接好_next指针
			}

			// 删除
			delete cur;
			--_n;// 记得将有效数据个数-1

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

哈希闭开散列实现整体代码GitHub

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux学习之Shell(一)

Linux学习之Shell(一)

Shell概述 1&#xff09;Linux提供的Shell解析器有 [xiaominghadoop101 ~]$ cat /etc/shells /bin/sh /bin/bash /sbin/nologin /usr/bin/sh /usr/bin/bash /usr/sbin/nologin /bin/tcsh /bin/csh2&#xff09;bash和sh的关系 [xiaominghadoop101 bin]$ ll | grep bash -rwxr…
阅读更多...
HTML ＜area＞ 标签

HTML ＜area＞ 标签

实例 带有可点击区域的图像映射： <img src="planets.jpg" border="0" usemap="#planetmap" alt="Planets" /><map name="planetmap" id="planetmap"><area shape="circle" coords=&q…
阅读更多...
不用花一分钱！！！获得一个自己的网页版chatGPT

不用花一分钱！！！获得一个自己的网页版chatGPT

不用花一分钱&#xff01;&#xff01;&#xff01;获得一个自己的网页版chatGPT 当然还是需要一个chatGPT账号的&#xff0c;不会注册的同学可以看一下这篇文章 chatGPT到底要怎么注册 那就先让我们看一下效果吧 chatgpt-web介绍 github项目地址 https://github.com/Chanzha…
阅读更多...
Formik使用详解

Formik使用详解

Formik使用详解 1 引言 在现代Web应用程序中&#xff0c;表单是一种不可避免的输入机制&#xff0c;但是处理表单的过程可能会变得非常复杂。Formik是一个React表单库&#xff0c;它的目标是简化表单处理的过程。本文将介绍Formik的主要功能和用途&#xff0c;以及如何使用它来…
阅读更多...
OSI七层网络模型+TCP/IP四层模型

OSI七层网络模型+TCP/IP四层模型

OSI七层模型&#xff1a; 物理层&#xff1a;主要定义物理设备标准&#xff0c;如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流&#xff08;就是由1、0转化为电流强弱来进行传输&#xff0c;到达目的地后再转化为1、0&#xff0c;也就…
阅读更多...
2023年淮阴工学院五年一贯制专转本财务管理基础考试大纲

2023年淮阴工学院五年一贯制专转本财务管理基础考试大纲

2023年淮阴工学院五年一贯制专转本财务管理基础考试大纲 一、考核对象 本课程的考核对象为五年一贯制高职专转本财务管理专业入学考试普通在校生考生。 二、考核方式 本课程考核采用闭卷笔试的方式。 三、命题依据及原则 1、命题依据 本课程考核命题教材为靳磊编著&…
阅读更多...
1_5 pytorch操作

1_5 pytorch操作

一、torch 算子 1、torch.nn.functional.affine_grid(theta, size) 给定一组仿射矩阵(theta)&#xff0c;生成一个2d的采样位置(流场)&#xff0c;通常与 grid_sample() 结合使用,用于空间仿射变换网络&#xff0c;用于对2D或3D数据进行仿射变换。 输入&#xff1a;theta(Te…
阅读更多...
AIGPT中文版（无需魔法，直接使用）不愧是生活工作的好帮手。

AIGPT中文版（无需魔法，直接使用）不愧是生活工作的好帮手。

AIGPT AIGPT是一款非常强大的人工智能技术的语言处理工具软件&#xff0c;它具有 AI绘画 功能、AI写作、写论文、写代码、哲学探讨、创作等功能&#xff0c;可以说是生活和工作中的好帮手。 我们都知道使用ChatGPT是需要账号以及使用魔法的&#xff0c;其中的每一项对我们初学…
阅读更多...
使用JPA自动生成代码（轻松上手看了就会版）

使用JPA自动生成代码（轻松上手看了就会版）

目录 背景&#xff1a;方案概念&#xff1a;JPA 的主要作用 jpa简单使用&#xff08;Springboot项目&#xff09;jpa进阶使用总结 背景&#xff1a; 项目需要自动生成sql代码&#xff0c;不需要写sql语句&#xff0c;能够自动进行查询&#xff0c;我想到了JPA。 方案 概念&a…
阅读更多...
Linux驱动编程（分层分离编程思想）

Linux驱动编程（分层分离编程思想）

1、面向对象 ⚫ 字符设备驱动程序抽象出一个 file_operations 结构体&#xff1b; ⚫ 我们写的程序针对硬件部分抽象出 led_operations 结构体。 2、分层 上层实现硬件无关的操作&#xff0c;比如注册字符设备驱动&#xff1a;leddrv.c 下层实现硬件相关的操作&#xff0c;比如…
阅读更多...
Makefile零基础教学(一)初识makefile

Makefile零基础教学(一)初识makefile

从这篇文章开始就开始进入 Makefile 的零基础教程&#xff0c;相信只要看了本教程的都可以对 Makefile 有一个清晰的理解和正确的运用。那么现在就开始我们的 Makefile 学习之路。 文章目录 一、什么是 Makefile&#xff0c;优点&#xff1f;二、什么是 make, 为什么使用make?…
阅读更多...
Linux学习记录——이십이 进程信号（1）

Linux学习记录——이십이 进程信号（1）

文章目录 1、了解信号2、了解信号处理3、信号产生1、键盘按键产生2、系统接口产生3、软件条件产生4、硬件异常 4、Core和Term的区别5、信号保存1、在系统中的表现形式2、信号集操作函数1、sigprocmask2、sigpending 6、重谈地址空间7、信号处理与捕捉sigaction 1、了解信号 信…
阅读更多...
MySQL索引、事务与存储引擎

MySQL索引、事务与存储引擎

数据库索引 是一个排序的列表&#xff0c;存储着索引值和这个值对应的物理地址&#xff0c;在这个列表中存储着索引的值和包含这个值的数据所在行的物理地址&#xff08;类似于C语言的链表通过指针指向数据记录的内存地址&#xff09;无需对整个表进行扫描&#xff0c;而是先通…
阅读更多...
IS210AEBIH3BEC隔离器用于变压器等高压设备

IS210AEBIH3BEC隔离器用于变压器等高压设备

IS210AEBIH3BEC隔离器用于变压器等高压设备 隔离器可以根据在电力系统中的位置进行分类 母线侧隔离器——隔离器直接连接到主母线线路侧隔离器 - 隔离器将放置在任何馈线的线路侧Transfer bus side isolator – isolator will be directly connected with the transfer bus S…
阅读更多...
【LeetCode】1143. 最长公共子序列

【LeetCode】1143. 最长公共子序列

1.问题 给定两个字符串 text1 和 text2&#xff0c;返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 &#xff0c;返回 0 。 一个字符串的 子序列 是指这样一个新的字符串&#xff1a;它是由原字符串在不改变字符的相对顺序的情况下删除某些字符&#xff0…
阅读更多...
怎么让chatGTP写论文-chatGTP写论文工具

怎么让chatGTP写论文-chatGTP写论文工具

chatGTP如何写论文 ChatGPT是一个使用深度学习技术训练的自然语言处理模型&#xff0c;可以用于生成自然语言文本&#xff0c;例如对话、摘要、文章等。作为一个人工智能技术&#xff0c;ChatGPT可以帮助你处理一些文字内容&#xff0c;但并不能代替人类的创造性思考和判断。以…
阅读更多...
手机录屏怎么操作？有哪些好用的方法

手机录屏怎么操作？有哪些好用的方法

在现代科技的时代&#xff0c;手机录屏已经成为了常见的操作。这项技术允许我们在手机上录制视频并分享给他人。但是&#xff0c;很多人可能并不知道如何进行手机录屏。下面我们将介绍手机录屏的操作方法和一些值得推荐的工具。 手机录屏操作方法 对于iOS用户&#xff0c;可以…
阅读更多...
Ribbon负载均衡

Ribbon负载均衡

目录 1.Ribbon负载均衡 1.1.负载均衡原理 1.2.源码跟踪 1&#xff09;LoadBalancerIntercepor 2&#xff09;LoadBalancerClient 3&#xff09;负载均衡策略IRule 4&#xff09;总结 1.3.负载均衡策略 1.3.1.负载均衡策略 1.3.2.自定义负载均衡策略 1.4.饥饿加载 1.R…
阅读更多...
InnoDB 与MyISAM 的区别

InnoDB 与MyISAM 的区别

MyISAM和InnoDB都是Mysql里面的两个存储引擎。 在Mysql里面&#xff0c;存储引擎是可以自己扩展的&#xff0c;它的本质其实是定义数据存储的方式以及数据读取的实现逻辑。 不同存储引擎本身的特性&#xff0c;使得我们可以针对性的选择合适的引擎来实现不同的业务场景。从而获…
阅读更多...
Java企业级信息系统开发01—采用spring配置文件管理bean

Java企业级信息系统开发01—采用spring配置文件管理bean

文章目录 一、Web开发技术二、spring框架&#xff08;一&#xff09;spring官网&#xff08;二&#xff09;spring框架优点&#xff08;三&#xff09;Spring框架核心概念1、IoC&#xff08;Inversion of Control&#xff09;和容器2、AOP&#xff08;Aspect-Oriented Programm…
阅读更多...
最新文章

Copyright @ 2022~2023