c++学习之哈希

目录

1.关于unordered系列关联式容器

2.关于unordered_map

 3.哈希（散列）表的实现

一，直接定址法

二，除留余数法

方法一：闭散列：开放定址法 

方法二：闭散列：哈希桶/拉链法

 4.哈希表的封装

哈希表封装后

unordered_map简单封装

unordered_set简单封装

1.关于unordered系列关联式容器

      在unordered系列关联式容器是C++11中新增的一组关联式容器，它们的 底层结构是哈希表 ， 而不是红黑树（我可以理解之前的map和set红黑树就是Tree_map Tree_set,这里的就是hash_map,hash_set） 。这些容器包括 unordered_map、unordered_set 、 unordered_multimap 和 unordered_multiset 。 它们的使用方式与红黑树结构的关联式容器基本相同，只是它们的底层结构不同。
相对于红黑树的Tree结构，hash这里更加强调的是特性，即unorder（无序性）。

 unordered_map和unordered_set是最常用的两个容器，它们的底层结构都是哈希，unordered_map是存储<key, value>键值对的关联式容器，它允许通过key快速的索引到与其对应的value。  

  在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。在内部，unordered_map没有对<key, value>按照任何特定的顺序排序，为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。

   unordered_set是一个存储唯一元素的集合，它的底层结构也是哈希表。它的元素是不可重复的，因此它的查询速度非常快。

2.关于unordered_map

先来看看库中的介绍：

对于map，还是以key_value为数据模型的，那么这里的key肯定也是不可以修改的，unodered_map强调的是查找效率，其次对于其迭代器是单向的。

对于它的接口也大差不差，，但是有两个我们没见过的，实际上在实现unordered_map中引入了其他参数及接口，如这里的负载因子(load_factor)，哈希桶（Buckts）.

 3.哈希（散列）表的实现

  什么是哈希呢？
     通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
插入元素--
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。
搜索元素--
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置
取元素比较，若关键码相等，则搜索成功。
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称
为哈希表(Hash Table)(或者称散列表)。
比如在做oj第一个出现的字符时，就可以通过字符的ASCLL与下标建立一一映射的关系。
那么对于这种结构，我们首先最重要的是就是去建立一一的映射关系 （关键值->存储位置） 。
线面说说两种定值方法：

一，直接定址法

所谓的直接定址法，即直接用该值（可以给这个值加或减或者不变）作为关键值，让每一个值都有一个唯一位置，让他的存储位置与该值建立关系。（用存储位置，表示key值）
但是当值太过于分散时，那么在映射时，就需要开辟足够大的空间，去存储。

 数据集中的时候我们开辟空间就小，但太分散时,如2作为key值插入位置2,95作为key插入位置95,9999插入位置9999.那对于空间无疑是巨大的浪费，那该怎么办呢？

二，除留余数法

有人就提出太大，那就对这个数取模，让它处在在一个合适的位置，比如上面7个数据，size为7，那就对每个数据模7，使它在这里个范围之内。

但是会出现新的问题，可能有数据会冲突，她两模完值是一样的，但对应的value是不一样的，这种问题被叫做哈希碰撞/哈希冲突，那么如何解决哈希碰撞呢？这时候有两种法案可以解决：

方法一：闭散列：开放定址法 

本质上就是如果新插入的数据的位置已经有数据了（value不一样），那就在这个开放的空间中，重新找一个空位置。这里也会有两种查找新位置的方法--1.线性探测（一个个往后找）2.二次探测（以2次方递增查找）。

如果冲突，我们就往后找没有被占的位置。可是当我们的后面空间快要满员时，此时再往后找新的位置，就可能位置存在不够的情况，那么在实际上，插入数据的个数在空间达到70%等的时候就需要扩容了，这里我么就引入了一个参数-负载因子（存储关键字的个数/空间大小）来空间空间大小。

为什么会有两种探测或者其他方式来寻找都是避免多次冲突，比如对于线性探测，重新找位置的话，如果有一部分数据是连续的，一个位置被提前占了，那么就会引起一片的哈希冲突，面对这个问题因此有了的探测二次探测。

那么我们就先来实现一下哈希表：

对于这里的负载因子，即不能太大，也不能太小，太大，容易发生冲突，太小，空间浪费太多。

这里我们一般使用0.7较为合适。

namespace myspace
{
	using namespace std;
	//如何去插入首先就需要对插入的每个位置做标记，该位置下可能存在三种状态，已经有数据，为空，之前有现在删除了
	enum State
	{
		EXIST,
		EMPTY,
		DELETE
	};
	//存放哈希表的数据的类型
	template<class K,class V>struct HashData
	{
		pair<K, V>  _kv;
		State _sta=EMPTY;
	};
	//类型转换，计算出key的大小，来确定平衡因子
	template<class K>struct HahFunc
	{
		size_t operator()(const K&k)
		{
			return size_t(k);
		}
	};
	template<>struct HahFunc<string>
	{
		//如果是字符串,我们用所有字符的ascll的和表示key
		//但是字符串之和也是有很大可能重合，很多人通过在数学方面的研究出了一些解决办法
		//这里最好的方式是采用的BKDR方法，给每个字符乘以31，131....这样的数 之后的和大概率不会重复
		size_t operator()(const string& k)
		{
			size_t sum = 0;
			for (int i = 0; i < k.size(); i++)
			{
				sum = sum * 31;
				sum=sum+k[i];
			}
			return sum;
		}
	
	};
template<class K, class V,class Hash=HahFunc<V>>class HashTable
{
public:
	HashTable()
	{
		//初始化空间为
		tables.resize(10);
	}

	bool insert( const pair<K,V>& kv)
	{
		if (find(kv.first) != NULL)
		{
			return false;
		}
		//负载因子决定是否扩容
		if (_n * 10 / tables.size() == 7)
		{
			//扩容
			//注意这里的扩容不能直接扩容，因为扩容之后size发生改变，对应的位置发生改变，因此需要重新开辟空间
			//在一个个重新（映射）插入，之后释放旧空间
			size_t newsize = tables.size() * 2;//扩二倍
			HashTable<K, V> newHaTa;
			newHaTa.tables.resize(newsize);//新表
			for (int i = 0; i < tables.size(); i++)
			{
				newHaTa.insert(tables[i]._kv);//重新走一遍映射再插入其中
			}
			
			//现在的需要的哈希表是新的，交换过来
			tables.swap(newHaTa.tables);

		}
		//通过取模size使得对应的位置在该size内
		Hash hf;
		size_t hashi = hf(kv.first % tables.size()) ;
		
		while (tables[hashi]._sta == EXIST)
		{
			//先确定好位置
			hashi++;
			hashi %= tables.size();
			
		}
		//再插入
		tables[hashi]._kv = kv;
		tables[hashi]._sta = EXIST;
		_n++;

		return true;
	}
	HashData<K,V>* find(const K &key)
	{
		Hash hf;
		size_t hashi = hf(key % tables.size());

		while (tables[hashi]._sta!=EMPTY )
		{
			if (tables[hashi]._sta==EXIST&&
				tables[hashi]._kv.first == key)
			{
				return &tables[hashi];
			}
			hashi++;
			hashi %= tables.size();
		}
		return NULL;
	}
	//伪删除
	bool erase(const K&key)
	{
		HashData<K, V> tmp = find(key);
		if (tmp)
		{
			tmp._sta == DELETE;
			_n--;
			return true;
		}
		else
		{
			return false;
		}
	}
	void Printf()
	{
		for (int i = 0; i < tables.size(); i++)
		{
			if (tables[i]._sta == EXIST)
			{
				cout<< i<<" " << tables[i]._sta << "->" << tables[i]._kv.first << endl;
			}
			else if (tables[i]._sta == DELETE)
			{
				cout << i <<" " << "DELETE" << tables[i]._kv.first << endl;
			}
			else if (tables[i]._sta == EMPTY)
			{
				cout << i <<" " << "EMPTY" << tables[i]._kv.first << endl;
			}
		}
	}

private:
	vector<HashData<K,V>> tables;
	size_t _n;//插入的关键字的个数
};
}

方法二：闭散列：哈希桶/拉链法

不同于上述的除留余数法，在实际的应用当中，而是引用哈希桶的方法，所谓的哈希桶，就是将哈希冲突的值放一起内部处理，此时整体结构就是vecor<list>型的结构。

     每一个key对应有一个桶，相同也没事，放在一起内部解决。

我来们可以将上面的挂着的链表理解为桶，里面存放着相同key的值，但是当存放的值太多，遍历桶里的值时间复杂度就是O(N)，效率太低，因此当长度达到某个界限时，就会换成红黑树来存放，提高查找效率。

在结构上，vector中的list，我们为了实现迭代器，我们自己写单链表，里面存放Node*，再插入时，我们采用头插的方式，如下图假设1，11，111他们的key值一样。

由于key类型不一定是整形，也有可能是其他类型，对于字符换类型，我们选他们的ascll码之和，再称31，用仿函数转化为size_t,以此来表示位置。

namespace Hash_Bucket
{
	using namespace std;
	template<class K>struct HahFunc
	{
		size_t operator()(const K& k)
		{
			return size_t(k);
		}
	};
	template<>struct HahFunc<string>
	{
		//如果是字符串,我们用所有字符的ascll的和表示key
		//但是字符串之和也是有很大可能重合，很多人通过在数学方面的研究出了一些解决办法
		//这里最好的方式是采用的BKDR方法，给每个字符乘以31，131....这样的数 之后的和大概率不会重复
		size_t operator()(const string& k)
		{
			size_t sum = 0;
			for (int i = 0; i < k.size(); i++)
			{
				sum = sum * 31;
				sum = sum + k[i];
			}
			return sum;
		}

	};
	template<class K, class V > struct HashNode
	{
		pair<K, V> _kv;
		HashNode* next;
		HashNode(const pair<K, V>& kv):_kv (kv),next(nullptr)
		{
			
		}

	};
	template<class K, class V,class Hash= HahFunc<K>>class HashTable
	{
	public:
		typedef HashNode<K, V> Node;
		HashTable()
		{
			_table.resize(10);
		}
		~HashTable()
		{
			//循环遍历释放桶的每一个节点
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}
		
		bool insert(const pair<K, V>& kv)
		{
		    Hash hf;
			if (find(kv.first))
			{
				//不插入相同的值
				return false;
			}
			//对于哈希桶，如果满了就要扩容，也就是负载因子为1
			if (_n == _table.size())
			{
				//第一种扩容方式，我们延续上面的扩容方式
				//size_t newsize = _table.size() * 2;//扩二倍
				//HashTable<K, V> newHaTa;
				//newHaTa.tables.resize(newsize);//新表
				//for (int i = 0; i < _table.size(); i++)
				//{
				//	Node* cur = _table[i];
				//	while (cur)
				//	{
					  //newHaTa.insert(cur->kv);//重新走一遍映射再插入其中
				//	}
				//	
				//}

				现在的需要的哈希表是新的，交换过来
				//_table.swap(newHaTa.tables);

				//没必要用上述方式，我们直接重新弄个表，把节点挪动下来
				vector<Node*> newtable;
				newtable.resize(2 * _table.size());
				for (int i = 0; i < _table.size(); i++)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* Next = cur->next;
						//重新映射到新表当中
						size_t hashi = hf(kv.first) % newtable.size();
						//头插
						cur->next = newtable[i];
						//表中的新头
						newtable[i] = cur;

						cur = Next;//遍历下一个
					}
					//旧表置空
					_table[i] == nullptr;
				}
			   //交换旧表与新表
				_table.swap(newtable);
			}
			//还是先通过取模节省空间
			size_t hashi = hf(kv.first) % _table.size();

				//头插
				Node* newnode = new Node(kv);
				newnode->next = _table[hashi];
				_table[hashi] = newnode;
				++_n;

				return true;
		}
		
		Node* find( const K&key)
		{
			Hash hf;
			size_t hashi = hf( key) % _table.size();

			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->next;
			}
			return NULL;
		}
		
		bool erase(const K* key)
		{
			Hash hf;
			size_t hashi = hf(key )% _table.size();
			Node* cur = _table[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//找到并删除
					//头删
					if (prev == nullptr)
					{
						_table[hashi] = cur->next;//如果头被断开为空，cur的下一个就是新头节点
					}
					else
					{
                          prev->next = cur->next;//和相对的头节点断开关系
					}
					
					delete cur;
					return true;
				}

				prev = cur;//上一个节点，相对下一节点的头节点
				cur = cur->next;//下一个节点
			}
			return false;
		}

		//那么实际上我们来看桶的大小其实并不会很大
		void Some()
		{
			size_t bucketSize = 0;
			size_t maxBucketLen = 0;
			size_t sum = 0;
			double averageBucketLen = 0;

			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					++bucketSize;
				}

				size_t bucketLen = 0;
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}

				sum += bucketLen;

				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}

			averageBucketLen = (double)sum / (double)bucketSize;

			printf("all bucketSize:%d\n", _tables.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}
		void Print()
		{
			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					if (cur)
					{
						cout << cur->_kv.first << cur->_kv.second << endl;
					}		
					cur = cur->next;
				}
			}

			cout << endl;
		}
    private:
		vector<Node*> _table;//这里存放节点指针,目的是为了实现迭代器
		size_t _n;
	};

可能有些人觉得哈希桶可能太长，效率可能太低 ，但实际上哈希桶并不会太长，通过BKDR，以及负载因子的控制，不会有太多相同的key值。因此哈希桶实现的哈希表效率与上述基本不差。4.

 4.哈希表的封装

对于哈希表的封装，和封装红黑树一样，我们可以封装出unordered_map与unordered_map。

首先就是统一哈希表的模板参数，直接传pair，哈希表中用T表示，通过仿函数传T张key的类型，

 之后就是实现迭代器，迭代器与哈希表两者相互依赖，需要提前声明，以及再哈希表中声明友元迭代器方便我们使用，在之后为了实现const迭代器，在传入参数Ref,Ptr作为T&,T*.

对于迭代器的封装，这里我们需要三个参数，分别是哈希表（也可用vector），结点指针，以及下标位置hashi，通过遍历判断实现前置++。

哈希表封装后

namespace Hash_Bucket
{
	using namespace std;
	template<class K>struct HahFunc
	{
		size_t operator()(const K& k)
		{
			return size_t(k);
		}
	};
	template<>struct HahFunc<string>
	{
		//如果是字符串,我们用所有字符的ascll的和表示key
		//但是字符串之和也是有很大可能重合，很多人通过在数学方面的研究出了一些解决办法
		//这里最好的方式是采用的BKDR方法，给每个字符乘以31，131....这样的数 之后的和大概率不会重复
		size_t operator()(const string& k)
		{
			size_t sum = 0;
			for (int i = 0; i < k.size(); i++)
			{
				sum = sum * 31;
				sum = sum + k[i];
			}
			return sum;
		}

	};
	template<class T > struct HashNode
	{
		T _data;
		HashNode* next;
		HashNode(const T& data):_data (data),next(nullptr)
		{
			
		}

	};
	//迭代器
	//由于迭代器与哈希表存在双向依赖
	//我们在这里给上前置声明
	template<class K, class T, class keyofT, class Hash>class HashTable;
	template<class K, class T, class Ref, class Ptr, class keyofT, class Hash>struct HTiterator
	{
		typedef HashNode< T > Node;
		HTiterator(Node*node, HashTable< K, T, keyofT, Hash>* _tab,size_t _hashi):_node(node), tab(_tab),hashi(_hashi)
		{

		}
		//这里除了传一个指针，还需要数组或整个表
		Node* _node;
		const HashTable< K, T, keyofT, Hash>* tab;
		size_t hashi;
		typedef HTiterator< K,  T, Ref,Ptr,keyofT,  Hash > self;

		//后置加加
		self &operator++()
		{
			if (_node->next)
			{
				//继续走这个桶
				_node = _node->next;
			}
			else
			{
				//下一个桶,找下一个桶
				++hashi;
				//新的桶
				while (hashi < tab->_table.size())
				{
					if (tab->_table[hashi])
					{
						//如果不为空，我的节点就是这个新节点
						_node = tab->_table[hashi];
						break;
					}
					else {
						++hashi;
					}
				}
				if (hashi == tab->_table.size())
				{
					_node = nullptr;
				}

			}
			return *this;
		}
		Ptr operator->()
		{
			return &(_node->data);
		}
		Ref operator*()
		{
			return (_node->_data);
		}
	    bool operator!=(const self &tmp)
		{
			return _node != tmp._node;
		}



	};




	template<class K,class T,class keyofT,class Hash= HahFunc<K>>class HashTable
	{
	public:
		//声明友元
		template<class K, class T,class Ref,class Ptr, class keyofT, class Hash >friend struct HTiterator;

		typedef HTiterator< K, T,T&,T*, keyofT, Hash > iterator;
		typedef HTiterator< K, T, const T&, const T*, keyofT, Hash > const_iterator;
		iterator begin()
		{
			for (int i = 0; i < _table.size(); i++)
			{
				if (_table[i])
				{
                   return iterator(_table[i],this,i);
				}
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this,-1);
		}
		const_iterator begin()const
		{
			for (int i = 0; i < _table.size(); i++)
			{
				if (_table[i])
				{
					return const_iterator(_table[i], this, i);
				}
			}
			return end();
		}
		const_iterator end()const
		{
			return const_iterator(nullptr, this, -1);
		}
		typedef HashNode<T> Node;
		HashTable()
		{
			_table.resize(10);
		}
		~HashTable()
		{
			//循环遍历释放桶的每一个节点
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}
		   Hash hf;
		   keyofT kot;
		bool insert(const T& data)
		{
		 
			if (find(kot(data)))
			{
				return false;
			}
			//对于哈希桶，如果满了就要扩容，也就是负载因子为1
			if (_n == _table.size())
			{
				vector<Node*> newtable;
				newtable.resize(2 * _table.size());
				for (int i = 0; i < _table.size(); i++)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* Next = cur->next;
						//重新映射到新表当中
						size_t hashi = hf(kot(data)) % newtable.size();
						//头插
						cur->next = newtable[i];
						//表中的新头
						newtable[i] = cur;

						cur = Next;//遍历下一个
					}
					//旧表置空
					_table[i] == nullptr;
				}
			   //交换旧表与新表
				_table.swap(newtable);
			}
			//还是先通过取模节省空间
			size_t hashi = hf(kot(data)) % _table.size();

				//头插
				Node* newnode = new Node(data);
				newnode->next = _table[hashi];
				_table[hashi] = newnode;
				++_n;

				return true;
		}
		
		Node* find( const K&key)
		{
			Hash hf;
			size_t hashi = hf( key) % _table.size();

			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return cur;
				}
				cur = cur->next;
			}
			return NULL;
		}
		
		bool erase(const K* key)
		{
			Hash hf;
			size_t hashi = hf(key )% _table.size();
			Node* cur = _table[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->data) == key)
				{
					//找到并删除
					//头删
					if (prev == nullptr)
					{
						_table[hashi] = cur->next;//如果头被断开为空，cur的下一个就是新头节点
					}
					else
					{
                          prev->next = cur->next;//和相对的头节点断开关系
					}
					
					delete cur;
					return true;
				}

				prev = cur;//上一个节点，相对下一节点的头节点
				cur = cur->next;//下一个节点
			}
			return false;
		}

		//那么实际上我们来看桶的大小其实并不会很大
		void Some()
		{
			size_t bucketSize = 0;
			size_t maxBucketLen = 0;
			size_t sum = 0;
			double averageBucketLen = 0;

			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				if (cur)
				{
					++bucketSize;
				}

				size_t bucketLen = 0;
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}

				sum += bucketLen;

				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}

			averageBucketLen = (double)sum / (double)bucketSize;

			printf("all bucketSize:%d\n", _table.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}
		void Print()
		{
			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					if (cur)
					{
						cout << kot(cur->data) << kot(cur->data) << endl;
					}		
					cur = cur->next;
				}
			}

			cout << endl;
		}
    private:
		vector<Node*> _table;//这里存放节点指针,目的是为了实现迭代器
		size_t _n;
	};

};

unordered_map简单封装

namespace myspace1
{
	using namespace std;
	template<class K, class V>class unordered_map
	{
		struct mapkeyofT
		{
			const K& operator()(const pair<K, V>& data)
			{
				return data.first;
			}
		};
	public:

		typedef typename Hash_Bucket::HashTable< K, pair<K, V>, mapkeyofT >::iterator iterator;
		
		iterator begin()
		{
			return table.begin();
		}
		iterator end()
		{
			return table.end();
		}
		bool insert(const pair<K, V>& kv)
		{
			return table.insert(kv);
		}
	private:
		Hash_Bucket::HashTable<K, pair<K, V>, mapkeyofT> table;
	};

	void test()
	{
		unordered_map<std::string, std::string> dictionary;
		dictionary.insert(std::make_pair<std::string, std::string>("苹果", "两个"));
		dictionary.insert(std::make_pair<std::string, std::string>("梨子", "两个"));
		dictionary.insert(std::make_pair<std::string, std::string>("香蕉", "两个"));
		unordered_map<std::string, std::string>::iterator it = dictionary.begin();
		while (it != dictionary.end())
		{
			cout << (*it).first<< (*it).second<<" ";
			++it;
		}
	}
};

unordered_set简单封装

namespace myspace2
{
	template<class K>class unodered_set
	{
		struct setkeyofT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename Hash_Bucket::HashTable< K,K>, setkeyofT >::iterator iterator;

		iterator begin()
		{
			return table.begin();
		}
		iterator end()
		{
			return table.end();
		}

		bool insert(const K& key)
		{
			return  table.insert(key);
		}
	private:
		Hash_Bucket::HashTable<K, K, setkeyofT> table;
	};
};

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

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

相关文章

设计模式——RBAC 模型详解

设计模式——RBAC 模型详解

1.什么是 RBAC 呢&#xff1f; RBAC 即基于角色的权限访问控制&#xff08;Role-Based Access Control&#xff09;。这是一种通过角色关联权限&#xff0c;角色同时又关联用户的授权方式。 简单地说&#xff1a;一个用户可以拥有若干角色&#xff0c;每一个角色又可以被分配…
阅读更多...
maven打包可执行jar含依赖lib

maven打包可执行jar含依赖lib

修改pom.xml <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><!-- jdk8可用&#xff0c;其他jdk版本可能需改插件版本 --><version>2.3.7.RE…
阅读更多...
内存可见性与指令重排序

内存可见性与指令重排序

文章目录 内存可见性内存可见性问题代码演示JMM&#xff08;Java Memory Model&#xff09; 指令重排序指令重排序问题代码演示指令重排序分析 volatile关键字volatile 保证内存可见性 & 禁止指令重排序volatile 不保证原子性 在上一节介绍线程安全问题的过程中&#xff0c…
阅读更多...
【计算思维】蓝桥杯STEMA 科技素养考试真题及解析 2

【计算思维】蓝桥杯STEMA 科技素养考试真题及解析 2

1、兰兰有一些数字卡片&#xff0c;从 1 到 100 的数字都有&#xff0c;她拿出几张数字卡片按照一定顺序摆放。想一想&#xff0c;第 5 张卡片应该是 A、11 B、12 C、13 D、14 答案&#xff1a;C 2、按照下图的规律&#xff0c;阴影部分应该填 A、 B、 C、 D、 答案&am…
阅读更多...
汇编-PROC定义子过程(函数)

汇编-PROC定义子过程(函数)

过程定义 过程用PROC和ENDP伪指令来声明&#xff0c; 并且必须为其分配一个名字(有效的标识符) 。目前为止&#xff0c; 我们所有编写的程序都包含了一个main过程&#xff0c; 例如&#xff1a; 当要创建的过程不是程序的启动过程时&#xff0c; 就用RET指令来结束它。RET强制…
阅读更多...
Arthas 监听 Docker 部署的java项目CPU占比高的信息

Arthas 监听 Docker 部署的java项目CPU占比高的信息

1、Linux上安装Arthas wget https://alibaba.github.io/arthas/arthas-boot.jar2、docker ps 查看目标项目的容器ID 3、copy Arthas 到目标容器中 (注意有 &#x1f615; ) docker cp arthas-boot.jar d97e8666666:/4、进入到目标容器目录中 docker exec -it d97e8666666 /b…
阅读更多...
FFmpeg 6.1 开放源码多媒体框架近日发布了重大更新

FFmpeg 6.1 开放源码多媒体框架近日发布了重大更新

导读FFmpeg 6.1 开放源码多媒体框架近日发布了重大更新&#xff0c;带来了新功能、新解码器、新过滤器和许多其他变化。 在 FFmpeg 6.0 “Von Neumann “版本发布八个多月后&#xff0c;FFmpeg 6.1 被命名为 “Heaviside”&#xff0c;引入了多线程 Vulkan 硬件加速解码&#x…
阅读更多...
【React-Router】路由快速上手

【React-Router】路由快速上手

1. 创建路由开发环境 # 使用CRA创建项目 npm create-react-app react-router-pro# 安装最新的ReactRouter包 npm i react-router-dom2. 快速开始 // index.jsimport React from react; import ReactDOM from react-dom/client; import ./index.css; import App from ./App; i…
阅读更多...
在终端输入任意的英文字符串，求最后一个单词的长度

在终端输入任意的英文字符串，求最后一个单词的长度

实例要求&#xff1a;1、在终端输入任意的英文字符串 s&#xff0c;由若干单词组成&#xff0c;单词前后用一些空格字符隔开&#xff1b;2、返回字符串中 最后一个 单词的长度&#xff1b;3、单词 是指仅由字母组成、不包含任何空格字符的最大子字符串&#xff1b;示例代码&…
阅读更多...
2023亚太杯数学建模竞赛（亚太赛）选题建议+初步分析

2023亚太杯数学建模竞赛（亚太赛）选题建议+初步分析

如下为C君的2023亚太杯数学建模竞赛&#xff08;亚太赛&#xff09;选题建议初步分析&#xff1a; 提示&#xff1a;DS C君认为的难度&#xff1a;C<A<B&#xff0c;开放度&#xff1a;A<B<C。 以下为ABC题选题建议及初步分析&#xff1a; A题&#xff1a;Image…
阅读更多...
Day38力扣打卡

Day38力扣打卡

打卡记录 网格中的最小路径代价&#xff08;动态规划&#xff09; 链接 class Solution:def minPathCost(self, grid: List[List[int]], moveCost: List[List[int]]) -> int:m, n len(grid), len(grid[0])f [[0x3f3f3f3f3f] * n for _ in range(m)]f[0] grid[0]for i i…
阅读更多...
文本分析：NLP 魔法！

文本分析：NLP 魔法！

一、说明 这是一个关于 NLP 和分类项目的博客。NLP 是自然语言处理&#xff0c;目前需求量很大。让我们了解如何利用 NLP。我们将通过编码来理解流程和概念。我将在本博客中介绍 BagOfWords 和 n-gram 以及朴素贝叶斯分类模型。这个博客的独特之处&#xff08;这使得它很长&…
阅读更多...
轻量封装WebGPU渲染系统示例＜38＞- 动态构建WGSL材质Shader(源码)

轻量封装WebGPU渲染系统示例＜38＞- 动态构建WGSL材质Shader(源码)

实现原理: 基于宏定义和WGSL功能文件实现 当前示例源码github地址: https://github.com/vilyLei/voxwebgpu/blob/feature/rendering/src/voxgpu/sample/DynamicShaderBuilding.ts 当前示例运行效果: 此示例基于此渲染系统实现&#xff0c;当前示例TypeScript源码如下&#x…
阅读更多...
【追求卓越04】数据结构--栈与队列

【追求卓越04】数据结构--栈与队列

引导 今天我们开始学习栈与队列的内容&#xff0c;我觉得栈并不难&#xff0c;所以篇幅也就不会那么多了。在虚拟空间中&#xff0c;栈是用户空间中的一种数据结构&#xff0c;它主要用于保存局部变量。那么问题来了&#xff0c;为什么用栈来保存局部变量&#xff0c;不用别的数…
阅读更多...
探秘开发app与小程序：一场技术与创新的博弈

探秘开发app与小程序：一场技术与创新的博弈

app与小程序&#xff1a;一场技术与创新的博弈随着科技的飞速发展&#xff0c;移动应用程序已经成为我们日常生活中不可或缺的一部分。在这个充满竞争的时代&#xff0c;企业纷纷投身于开发各类移动应用&#xff0c;以期在市场中占据一席之地。然而&#xff0c;面对多样化的应用…
阅读更多...
从0开始学习JavaScript--JavaScript迭代器

从0开始学习JavaScript--JavaScript迭代器

JavaScript迭代器&#xff08;Iterator&#xff09;是一种强大的编程工具&#xff0c;它提供了一种统一的方式来遍历不同数据结构中的元素。本文将深入探讨JavaScript迭代器的基本概念、用法&#xff0c;并通过丰富的示例代码展示其在实际应用中的灵活性和强大功能。 迭代器的…
阅读更多...
Redis-Redis缓存高可用集群

Redis-Redis缓存高可用集群

1、Redis集群方案比较 哨兵模式 在redis3.0以前的版本要实现集群一般是借助哨兵sentinel工具来监控master节点的状态&#xff0c;如果master节点异常&#xff0c;则会做主从切换&#xff0c;将某一台slave作为master&#xff0c;哨兵的配置略微复杂&#xff0c;并且性能和高可…
阅读更多...
ubuntu cutecom串口调试工具使用方法（图形界面）

ubuntu cutecom串口调试工具使用方法（图形界面）

文章目录 Ubuntu下使用CuteCom进行串口调试使用指南什么是CuteCom&#xff1f;主要特点 安装CuteCom使用APT包管理器从源码编译安装 配置串口CuteCom界面解析&#xff08;启动cutecom&#xff09;使用CuteCom进行数据发送和接收配置串口参数数据接收数据发送 高级功能和技巧流控…
阅读更多...
Pycharm的程序调试

Pycharm的程序调试

有如下代码需要进行调试&#xff1a; i 1 while i < 10:print(i)步骤一&#xff1a;设置断点 步骤二&#xff1a;进入调试视图 方式1&#xff1a;右键单击编辑区&#xff1a;点击’Debug模块名’ ​ 方式2&#xff1a;ShiftF9 ​ 方式3&#xff1a;单机工具栏上的调试按钮…
阅读更多...
Bean依赖注入注解开发

Bean依赖注入注解开发

value Value("xfy")private String userName;private String userName;Value("xiao")public void setUserName(String userName) {this.userName userName;} Autowired // 根据类型进行注入 如果同一类型的Bean有多个&#xff0c;尝试根基名字进行二次…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站