【C++进阶】哈希表

news2025/1/11 13:59:44

文章目录

  • 前言
  • 哈希概念
  • 哈希冲突
  • 哈希函数
  • 哈希冲突解决
    • 一.闭散列解决哈希冲突
      • 1. 线性探测
      • 2.二次探测
    • 二、闭散列的实现
      • 1.准备
      • 2.闭散列插入
      • 3.闭散列查找
      • 4.闭散列删除
    • 三、闭散列完整源码
    • 四、开散列解决哈希冲突
      • 1.开散列概念
      • 2.哈希桶的结构
      • 3.哈希桶的插入
      • 4.哈希桶的查找
      • 5.哈希桶的删除
    • 五、开散列完整代码

前言

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构,例unordered_map和unordered_set相比map和set查找效率会高很多，因为哈希结钩在查找方面优势很大。

哈希概念

红黑树的本质是一颗二叉搜索树，而一颗二叉搜索树想要查找必须通过比较大小而确定向左还是向右，而如果使用顺序表的话必须全部走一遍，走顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。
那么是否有一种结钩是不需要多次比较来插入，删除，查找元素呢？

哈希表就是这样一种结钩，通过映射来使存储位置和处理的元素建立联系，如果要找这个元素，就可以通过哈希表直接映射到某一位置。

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

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

例如：数据集合{1，7，6，4，5，9}； 哈希函数设置为：hash(key) = key % capacity;
capacity为存储元素底层空间总的大小。
在这里插入图片描述

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

如果44继续插入到集合中，44%10=4，这时就和之前插入的4冲突了，就会出现哈希冲突问题，对于哈希冲突问题，要采取一些方法来解决。

哈希冲突

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

哈希函数

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

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

有下边一些哈希函数：

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

哈希冲突解决

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

一.闭散列解决哈希冲突

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

1. 线性探测

线性探测：从冲突位置开始，一直向后探测，一直找到一个空位置为止。

插入：插入就是通过哈希函数求得的值，判断该位置是否有数据，如果有，就继续逐一向后探测，如果找到不为空的位置，那么就将该数据插入到哈希表中。
查找：通过哈希函数求得一个位置，判断表中数据与该数据是否相等，如果不相等，就继续向后寻找，如果找到空位置，那么说明哈希表中不存在该数据。
删除:采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

例如在下图中：
当要插入44时，使用除留余数法，44对10求余等于4，所以从表中下标为4的位置查找空位置，若为空，就插入，若不为空，就继续向后探测，为空后插入，所以44在下标为8的位置插入。
在这里插入图片描述
当表中数据较满时，在进行线性探测可能效率就会大大降低，所以必须规定负载因子的大小，来保证哈希表中一部分位置为空，通常设置的负载因子为0.7到0.8.
在这里插入图片描述
对于负载因子，我们可以来定性分析：

若负载因子大，缺点就是冲突的概率越大，即增删查改的效率降低，优点是空间利用率高。
若负载因子小，缺点是空间利用率低，缺点是冲突的概率越小，即增删查改的效率降高。

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

那么就可以引入二次探测

2.二次探测

二次探测的含义并不是探测两次，而是使用平方后的数据向后探测。
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： 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是表的大小。
在这里插入图片描述
当要插入44时，第一次就是在下标为4的地方判断，第二次在4+1的平方处判断，第二次在4+2的平方处判断，第三次在4+3的平方处判断，直到找到空位置插入。

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

二、闭散列的实现

1.准备

状态标记
由于在哈希表中删除只能使用伪删除，所以必须对一个位置的状态进行标记，分为存在，删除，空三种状态。

	//枚举每个位置的状态
	enum State
	{
		EMPTY,
		DELETE,
		EXIST
	};

为了表示数据的状态，所以必须定义一个数据类型

	//每个位置数据类型
	template<class K, class V>
	class HashData
	{
	public:
		pair<K, V> _kv;
		State _state = EMPTY;
	};

在求hashi时，由于哈希函数使用除留余数法，所以key必须重载求余符号%，例如如果key是string类型的，就必须将string类型的key转为size_t类型，所以使用仿函数，在求余时调用仿函数。

	template<class K>
	class HashFunc
	{
	public:
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	template<>
	class HashFunc<string>
	{
	public:
		size_t operator()(const string& k)
		{
			size_t val = 0;
			for (auto e : k)
			{
				val *= 131;
				val += e;
			}
			return val;
		}
	};

2.闭散列插入

闭散列插入可以使用线性探测，也可以使用二次探测，只是在寻找空位置时有所不同，但是扩容操作是相同的，当负载因子大于0.7或者表的大小为0时，就必须进行扩容。

扩容：

由于扩容后，本来冲突的值现在不冲突了，也可能本来不冲突的值现在冲突了，所以必须重新进行插入，所以我们重新定义一个HashTable类，并且将哈希表的大小扩容到原来的二倍，然后将原表中的数依次插入，最后交换新表和旧表。

bool insert(const pair<K,V>& kv)
		{
			Hash hash;
			if (find(kv.first))
			{
				return false;
			}
			//扩容
			if (_tables.size() == 0 || _size * 10 / _tables.size() >= 7)
			{
				size_t NewSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> NewHT;
				NewHT._tables.resize(NewSize);
				for (HashData<K, V> e : _tables)
				{
					if (e._state == EXIST)
					{
						NewHT.insert(e._kv);
					}
				}

				_tables.swap(NewHT._tables);
			}

			线性探测
			//size_t hashi = hash(kv.first) % _tables.size();
			HashData<K, V> NewData = new HashData<K, V>(kv);
			//while (_tables[hashi]._state == EXIST)
			//{
			//	hashi++;
			//	hashi %= _tables.size();
			//}
			//_tables[hashi]._kv = kv;
			//_tables[hashi]._state = EXIST;
			//_size++;
			

			//二次探测
			size_t start = hash(kv.first) % _tables.size();
			int i = 0;
			size_t hashi = start;
			while (_tables[hashi]._state == EXIST)
			{
				++i;
				hashi = start + i*i;
				hashi %= _tables.size();
			}

			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			_size++;
			return true;
		}

3.闭散列查找

使用哈希函数求得存储位置时，判断表中hashi位置的值与要查找的值是否相同，不同的话，线性探测就逐一往后判断，二次探测就以平方的方式向后探测，直到找到数值相同的值，返回位置的地址。

		HashData<K,V>* find(const K& key)
		{
			Hash hash;
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = hash(key) % _tables.size();
			size_t start = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi %= _tables.size();

				if (hashi == start)
				{
					break;
				}
			}
			return nullptr;
		}

4.闭散列删除

通过find函数来获得key对应的指针，如果没有找到，返回false，如果查找到，只将该位置的状态改为DELETE，再将数据个数减一。

		bool erase(const K& key)
		{
			auto data = find(key);
			if (data == nullptr)
			{
				return false;
			}
			data->_state = DELETE;
			_size--;
			return true;
		}

三、闭散列完整源码

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

	template<class K>
	class HashFunc
	{
	public:
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	template<>
	class HashFunc<string>
	{
	public:
		size_t operator()(const string& k)
		{
			size_t val = 0;
			for (auto e : k)
			{
				val *= 131;
				val += e;
			}
			return val;
		}
	};
namespace CloseHash
{
	//枚举每个位置的状态
	enum State
	{
		EMPTY,
		DELETE,
		EXIST
	};
	//每个位置数据类型
	template<class K, class V>
	class HashData
	{
	public:
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	//哈希表
	template<class K, class V,class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		bool insert(const pair<K,V>& kv)
		{
			Hash hash;
			if (find(kv.first))
			{
				return false;
			}
			//扩容
			if (_tables.size() == 0 || _size * 10 / _tables.size() >= 7)
			{
				size_t NewSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> NewHT;
				NewHT._tables.resize(NewSize);
				for (HashData<K, V> e : _tables)
				{
					if (e._state == EXIST)
					{
						NewHT.insert(e._kv);
					}
				}

				_tables.swap(NewHT._tables);
			}

			线性探测
			//size_t hashi = hash(kv.first) % _tables.size();
			HashData<K, V> NewData = new HashData<K, V>(kv);
			//while (_tables[hashi]._state == EXIST)
			//{
			//	hashi++;
			//	hashi %= _tables.size();
			//}
			//_tables[hashi]._kv = kv;
			//_tables[hashi]._state = EXIST;
			//_size++;
			

			//二次探测
			size_t start = hash(kv.first) % _tables.size();
			int i = 0;
			size_t hashi = start;
			while (_tables[hashi]._state == EXIST)
			{
				++i;
				hashi = start + i*i;
				hashi %= _tables.size();
			}

			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			_size++;
			return true;
		}
		HashData<K,V>* find(const K& key)
		{
			Hash hash;
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = hash(key) % _tables.size();
			size_t start = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi %= _tables.size();

				if (hashi == start)
				{
					break;
				}
			}
			return nullptr;
		}
		bool erase(const K& key)
		{
			auto data = find(key);
			if (data == nullptr)
			{
				return false;
			}
			data->_state = DELETE;
			_size--;
			return true;
		}
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i]._state == EXIST)
				{
					printf("[%d:%d] ", i, _tables[i]._kv.first);
				}
				else
				{
					printf("[%d:*] ", i);
				}
			}
			cout << endl;
		}
	private:
		vector<HashData<K, V>> _tables;
		size_t _size = 0;
	};

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

		ht.Print();
	}
	void TestHT2()
	{
		string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

		//HashTable<string, int, HashFuncString> countHT;
		HashTable<string, int> countHT;
		for (auto& str : arr)
		{
			auto ptr = countHT.find(str);
			if (ptr)
			{
				ptr->_kv.second++;
			}
			else
			{
				countHT.insert(make_pair(str, 1));
			}
		}
		countHT.erase("苹果");
	}
	void TestHT3()
	{
		HashFunc<string> hash;
		cout << hash("abcd") << endl;
		cout << hash("bcad") << endl;
		cout << hash("eat") << endl;
		cout << hash("ate") << endl;
		cout << hash("abcd") << endl;
		cout << hash("aadd") << endl << endl;

		cout << hash("abcd") << endl;
		cout << hash("bcad") << endl;
		cout << hash("eat") << endl;
		cout << hash("ate") << endl;
		cout << hash("abcd") << endl;
		cout << hash("aadd") << endl << endl;
	}
}

四、开散列解决哈希冲突

1.开散列概念

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
例如上图就是哈希桶的结构，每一个哈希桶就是一个指针数组，存储着插入节点的指针，若此时插入44，也会与4进行冲突，此时将44头插到哈希桶的4下标处。
在这里插入图片描述
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

2.哈希桶的结构

由于冲突的结点是以单链表的形式保存的，所以在哈希桶中插入一个数据实际上是插入一个节点，并且哈希表中存储的就是冲突元素组成的单链表的头结点。

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

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		typedef HashNode<K, V> Node;
			private:
		vector<Node*> _tables;
		size_t _size = 0;
	};

3.哈希桶的插入

在插入时，首先判断哈希桶中是否已经存在这个数据，若存在，就返回false，插入失败。
如果负载因子等于1时，即哈希表的长度等于节点的个数时，就要进行扩容，在扩容时对哈希桶逐一遍历，将原哈希桶中的节点都取下来插入到新的哈希桶中。

		bool insert(const pair<K, V>& kv)
		{
			Hash hash;
			if (find(kv.first))
			{
				return false;
			}
			if (_size == _tables.size())
			{
				size_t NewSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> NewTables;
				NewTables.resize(NewSize, nullptr);

				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					if (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(cur->_kv.first) % _tables.size();
						cur->_next = NewTables[hashi];
						NewTables[hashi] = cur;

						cur = next;
					}
					_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;

			_size++;

			return true;
		}

4.哈希桶的查找

对哈希表进行遍历，每一个哈希表中都存着一个单链表的头结点，对单链表再进行查找，若存在返回节点的指针。

		Node* find(const K & key)
		{
			Hash hash;
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = hash(key) % _tables.size();
			while (_tables[hashi])
			{
				if (_tables[hashi]->_kv.first == key)
				{
					return _tables[hashi];
				}
				_tables[hashi] = _tables[hashi]->_next;
			}
			return nullptr;
		}

5.哈希桶的删除

因为哈希桶是有多个单链表构成，所以无法找到父结点，所以删除不能使用find进行查找，必须保存父节点，才能够删除节点。

		bool earse(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 (cur == _tables[hashi])
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_size;

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

五、开散列完整代码

namespace HashBucket
{
	template<class K, class V>
	class HashNode
	{
	public:
		typedef HashNode<K, V> Node;
		HashNode(const pair<K,V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
		pair<K, V> _kv;
		Node* _next;
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		typedef HashNode<K, V> Node;
		bool insert(const pair<K, V>& kv)
		{
			Hash hash;
			if (find(kv.first))
			{
				return false;
			}
			if (_size == _tables.size())
			{
				size_t NewSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> NewTables;
				NewTables.resize(NewSize, nullptr);

				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					if (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(cur->_kv.first) % _tables.size();
						cur->_next = NewTables[hashi];
						NewTables[hashi] = cur;

						cur = next;
					}
					_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;

			_size++;

			return true;
		}
				
		Node* find(const K & key)
		{
			Hash hash;
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = hash(key) % _tables.size();
			while (_tables[hashi])
			{
				if (_tables[hashi]->_kv.first == key)
				{
					return _tables[hashi];
				}
				_tables[hashi] = _tables[hashi]->_next;
			}
			return nullptr;
		}

		bool earse(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 (cur == _tables[hashi])
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_size;

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

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


	//void TestHT1()
	//{
	//	int a[] = { 1, 11, 4, 15, 26, 7, 44,55,99,78 };
	//	HashTable<int, int> ht;
	//	for (auto e : a)
	//	{
	//		ht.insert(make_pair(e, e));
	//	}

	//	ht.insert(make_pair(22, 22));
	//}
	void TestHT2()
	{
		string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

		//HashTable<string, int, HashFuncString> countHT;
		HashTable<string, int> countHT;
		for (auto& str : arr)
		{
			auto ptr = countHT.find(str);
			if (ptr)
			{
				ptr->_kv.second++;
			}
			else
			{
				countHT.insert(make_pair(str, 1));
			}
		}
		countHT.earse("苹果");
	}
}

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

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

相关文章

学习多线程

学习多线程

1、学习线程池 1.1jdk中的线程池 推荐使用ThreadPoolExecutor 1.1.1先了解参数的意义 首先看下ThreadPoolExecutor的构造函数 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueu…
阅读更多...
对话e签宝，解读 SaaS圈“头部玩家”的增长故事

对话e签宝，解读 SaaS圈“头部玩家”的增长故事

可以肯定的是&#xff0c;未来3年&#xff0c;整个中国SaaS市场会逐步确认船票分配。穿越周期&#xff0c;告别不确定的三年&#xff0c;给幸存下来的企业上了淋漓生动的一课。在新的起点上&#xff0c;SaaS也需要一种新的打开方式。谁扎得牢、想得透、做的好、跑得快&#xff…
阅读更多...
Docker数据卷和数据卷容器应用

Docker数据卷和数据卷容器应用

学习目的 掌握Docker数据卷和数据卷容器使用方法。 学习准备 要求实验主机能够连接外网&#xff0c;已经正确安装Docker&#xff0c;并关闭防火墙和selinux。 学习步骤 步骤1&#xff1a;创建数据卷 &#xff08;1&#xff09;创建容器&#xff0c;为容器添加一个数据卷&…
阅读更多...
基于树莓派4B与STM32的智能门禁系统项目（代码开源）

基于树莓派4B与STM32的智能门禁系统项目（代码开源）

前言&#xff1a;本文为手把手教学嵌入式经典项目——智能门禁项目&#xff0c;本次项目采用 树莓派4B 与 STM32F103C8T6 进行联合开发。项目充分发挥各自 CPU 的优势与长处&#xff0c;将人脸识别的大计算量任务给树莓派4B&#xff0c;将门禁系统的控制部分交给 STM32 进行处理…
阅读更多...
外包干了2个月，技术退步明显...

外包干了2个月，技术退步明显...

先说一下自己的情况&#xff0c;大专生&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近4年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了四年的功能测试…
阅读更多...
举个栗子！Quick BI 技巧（1）：创建趋势折线图

举个栗子！Quick BI 技巧（1）：创建趋势折线图

自 2016 年以来&#xff0c;优阅达《举个栗子》内容专栏已陪伴众多企业用户高效工作&#xff0c;解决真实业务场景中的用数问题。 2023 年&#xff0c;全新系列《举个栗子&#xff01;Quick BI 技巧》出炉啦~ 优阅达期待能够持续分享经验&#xff0c;帮助用户发现更多 Quick …
阅读更多...
剑指 Offer. 二叉树中和为某一值的路径

剑指 Offer. 二叉树中和为某一值的路径

给你二叉树的根节点 root 和一个整数目标和 targetSum &#xff0c;找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。 叶子节点 是指没有子节点的节点。 示例 1&#xff1a; 输入&#xff1a;root [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum 22 输出&…
阅读更多...
ATA3000系列功率放大器——水声信号中的典型应用

ATA3000系列功率放大器——水声信号中的典型应用

ATA3000系列功率放大器——水声信号中的典型应用 水声领域介绍&#xff1a; 主动声纳是通过声纳本身发射声波&#xff0c;根据声信号反射回波来发现目标&#xff0c;并测定目标的位置和运动参数。水声信号发射机在主动声纳设备中是非常重要的组成部分&#xff0c;其产生特定形式…
阅读更多...
YoloV5/YoloV7改进---注意力机制:引入瓶颈注意力模块BAM，对标CBAM

YoloV5/YoloV7改进---注意力机制:引入瓶颈注意力模块BAM，对标CBAM

目录 1.BAM介绍 2.BAM引入到yolov5 2.1 加入common.py中&#xff1a; 2.2 加入yolo.py中&#xff1a; 2.3 yolov5s_BAM.yaml 1.BAM介绍 论文&#xff1a;https://arxiv.org/pdf/1807.06514.pdf 摘要&#xff1a;提出了一种简单有效的注意力模块&#xff0c;称为瓶颈注意力模块…
阅读更多...
【数据仓库】Apache Doris介绍

【数据仓库】Apache Doris介绍

Apache Doris介绍 Apache Doris应用场景 Apache Doris核心特性 Apache Doris架构 Doris数据模型三种 Aggregate模型介绍 Uniq模型介绍 在某些多维分析场景下,用户更关注的是如何保证Key的唯一性Key 唯一性约束。因此&#xff0c;我们引入了 Unig 的数据模型。该模型本质上是聚…
阅读更多...
微信如何创建自己的小程序？

微信如何创建自己的小程序？

微信如何创建自己的小程序&#xff1f;微信小程序成为了很多商家、企业甚至是个人在互联网中的营销工具&#xff0c;微信小程序基本上可以说是属于必备工具。那么微信如何创建自己的小程序呢&#xff1f;下面一起来给大家说说。 一、注册小程序账号 微信如何创建自己的小程序…
阅读更多...
12.JavaWeb-Node.js

12.JavaWeb-Node.js

1.Node.js的概念 传统的Web服务器中&#xff0c;每个请求都会创建一个线程&#xff0c;这会导致线程数的增加&#xff0c;从而影响服务器的性能和扩展性&#xff0c;Ryan Dahl借助Chrome的V8引擎提供的能力实现了Node.js——可以在服务端运行的JavaScript&#xff08;可以把Nod…
阅读更多...
win下实现Linux的tab自动补全

win下实现Linux的tab自动补全

声明 &#xff1a;如果不是确定的话 注册表这个东西不建议更改 如果更改的话建议先备份系统 以防意外 1.找到注册表编辑器 2. 展开HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor 3.找到Completion Char 双击 把橙色的数值改成9 4.重新打开cmd 就可以了 参考文章…
阅读更多...
【Python数据处理】-Pandas笔记

【Python数据处理】-Pandas笔记

Python数据处理-Pandas笔记 &#x1f4dd; 基本概念 Pandas是一个强大的Python数据处理库&#xff0c;它提供了高效的数据结构和数据分析工具&#xff0c;使数据处理变得简单而快速。本篇笔记将介绍Pandas中最常用的数据结构——Series和DataFrame&#xff0c;以及数据处理的…
阅读更多...
48. Compose自定义绘制日历-2

48. Compose自定义绘制日历-2

这次的实现方式完全改了&#xff0c;感觉最初的想法对切换周历模式比较难实现&#xff0c; 现在是把月历和周历 同时生成&#xff0c;动态切换。 待优化的&#xff1a;切换的时候 闪动没那么丝滑。 还有另一种实现方案 &#xff1a; 只生成当前月份 和前后月份三组数据&#x…
阅读更多...
HTML5网页设计小案例：逸仙园茶馆招聘启事网页的设计

HTML5网页设计小案例：逸仙园茶馆招聘启事网页的设计

前言&#xff1a; 今天分享的逸仙园茶馆招聘启事网页的设计是本专栏的第一篇博客&#xff0c;也是我学习了几个小时知识点后写的实战小案例。我有个想法&#xff0c;想以逸仙园茶馆为灵感不断优化改进代码与想法设计一套与茶叶有关的的精美网页 逸仙园茶馆招聘启事网页的设计案…
阅读更多...
【动态规划上分复盘】这是你熟悉的地下城游戏吗？

【动态规划上分复盘】这是你熟悉的地下城游戏吗？

欢迎 前言一、动态规划五步曲二、地下城游戏题目分析思路&#xff1a;动态规划具体代码如下 总结 前言 本文讲解关于动态规划思路的两道题目。 一、动态规划五步曲 1.确定状态表示&#xff08;确定dp数组的含义&#xff09;2.确定状态转移方程&#xff08;确定dp的递推公式&a…
阅读更多...
NumPy实现逻辑回归

NumPy实现逻辑回归

说明&#xff1a;数据集 ex2data1.txt是吴恩达机器学习的作业的数据集。 # -*-coding:utf-8-*- import matplotlib.pyplot as plt import numpy as np import pandas as pdclass Logitstic_Regression:def __init__(self, learning_rate0.01, num_iterations75000, threshold0.…
阅读更多...
# 技术架构演进之路

# 技术架构演进之路

技术架构演进之路 文章目录 技术架构演进之路单机架构应用数据分离架构应用服务集群架构读写分离架构冷热分离架构垂直分库架构微服务架构容器编排技术互联网架构 单机架构 简介应用和服务公用一台服务器出现原因出现在互联网早期,访问量比较小,单机足以满足需求.架构工作原理…
阅读更多...
本地新项目推送至gitlab仓库

本地新项目推送至gitlab仓库

1. gitlab上新建一个空白项目 gitlab上点击new project按钮&#xff0c;新建一个项目 新建空白项目 项目名称与本地新建项目名称相同&#xff0c;其余根据具体需要选择 2. 初始化本地仓库并commit项目 进入本地项目根目录下&#xff0c;右击 git bash here打开命令窗口 初始化…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023