unordered_map和unordered_set模拟实现

news2024/11/18 3:46:30

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

一、哈希

1.1哈希概念

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

1.2哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

1.3哈希函数

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

常见的哈希函数：

1.直接定址法：

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

优点：简单、均匀

缺点：需要事先知道关键字的分布情况

使用场景：适合查找比较小且连续的情况

2.除留余数法：

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

1.4哈希冲突解决

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

1.4.1闭散列

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

1.线性探测

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

删除：删除时不可以物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。因为在查找时，遇到空就查找结束。

线性探测的实现：

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

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

namespace open_address//开放地址法
{
	//状态
	enum STATE
	{
		EMPTY, EXIST, DELETE//空，存在，删除
	};

	//数据类型
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		STATE _state = EMPTY;
	};

	template<class K, class V, class HashFunc = DefaultHashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
		{
			_table.resize(10);
		}

		bool insert(const pair<K, V>& kv)
		{
			//检查是否已经存在
			if (Find(kv.first))
				return false;
			//判断扩容
			HashFunc ht;
			int fac = (double)_n / _table.size();//负载因子
			if (fac >= 0.7)
			{
				//扩容之后可能会改变数据的映射关系，所以不能直接扩容
				size_t newcapacity = _table.capacity() * 2;
				HashTable<K, V> newHash;
				newHash._table.resize(newcapacity);
				//遍历旧表，插入到新表
				for (int i = 0; i < _table.capacity(); i++)
				{
					//只有exist状态的才插入新表
					if (_table[i]._state == EXIST)
						newHash.insert(_table[i]._kv);
				}
				_table.swap(newHash._table);
			}

			//插入
			size_t hashi = ht(kv.first) % _table.size();
			while (_table[hashi]._state == EXIST)
			{
				hashi++;
				if (hashi == _table.size())//回到0位置
					hashi = 0;
			}
			_table[hashi]._kv = kv;
			_table[hashi]._state = EXIST;
			_n++;
			return true;
		}

		HashData<const K, V>* Find(const K& key)
		{
			HashFunc ht;
			size_t hashi = ht(key) % _table.size();
			while (_table[hashi]._state != EMPTY)
			{
				if (_table[hashi]._state != DELETE && _table[hashi]._kv.first == key)
					return (HashData<const K, V>*) & _table[hashi];
				hashi++;
				//转回去继续找
				if (hashi == _table.size())//回到0位置
					hashi = 0;
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashData<const K, V>* data = Find(key);
			if (data)
			{
				data->_state = DELETE;
				_n--;
				return true;
			}
			return false;
		}
	private:
		vector<HashData<K, V>> _table;
		size_t _n = 0;//存储数据的有效个数
	};
}

哈希表什么情况下扩容？如何扩容？

2.二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：

若当前key与原来key产生相同的哈希地址，则当前key存在该地址后偏移量为（1,-1,2,-2,3,-3...）的二次方地址处
key1：hash(key)+0

key2：hash(key)+1^2

key3：hash(key)+(-1)^2

key4：hash(key)+2^2

key5：hash(key)+(-2)^2

1.4.2开散列

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

开散列的实现：


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

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


namespace hash_bucket//拉链法——哈希桶
{

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

		pair<K, V> _kv;
		HashNode<K, V>* _next;
	};

	template<class K, class V, class HashFunc = DefaultHashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_table.resize(10, nullptr);
		}

		~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;
			}
			_n = 0;
		}

		bool insert(const pair<K, V>& kv)
		{
			//检查是否已经存在
			if (Find(kv.first))
				return false;
			HashFunc ht;
			size_t fac = (double)_n / _table.size();//负载因子
			if (fac >= 1)//扩容
			{
				size_t newcapacity = _table.size() * 2;
				HashTable<K, V> newht;
				newht._table.resize(newcapacity, nullptr);
				//遍历旧的，链入新的
				for (int i = 0; i < _table.size(); i++)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;
						cur->_next = nullptr;//如果用屏蔽的方式，这里要置空
						size_t hashi = ht(cur->_kv.first) % newcapacity;
						//头插

						cur->_next = newht._table[hashi];
						newht._table[hashi] = cur;

						/*if (newht._table[hashi] == nullptr)
						{
							newht._table[hashi] = cur;
						}
						else
						{
							cur->_next = newht._table[hashi];
							newht._table[hashi] = cur;
						}*/
						cur = next;
					}
					_table[i] = nullptr;//这里必须要置空，否则不能释放
				}
				_table.swap(newht._table);
			}
			//头插
			Node* newnode = new Node(kv);
			size_t hashi = ht(kv.first) % _table.size();//找第几个桶

			newnode->_next = _table[hashi];
			_table[hashi] = newnode;

			/*if (_table[hashi] == nullptr)
			{
				_table[hashi] = newnode;
			}
			else
			{
				newnode->_next = _table[hashi];
				_table[hashi] = newnode;

			}*/
			_n++;
			return true;
		}

		Node* Find(const K& key)
		{
			HashFunc ht;
			size_t hashi = ht(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashFunc ht;
			size_t hashi = ht(key) % _table.size();
			Node* prev = nullptr;
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;

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

		void Print()
		{
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				printf("[%d] : ", i);
				while (cur)
				{
					cout << "(" << cur->_kv.first << ":" << cur->_kv.second << ")" << "->";
					cur = cur->_next;
				}
				cout << "NULL" << endl;
			}
			cout << endl;
		}

	private:
		vector<Node*> _table;
		size_t _n = 0;//存放有效数据的个数
	};
}

注意：如果我们要存放的数据是整型，可以使用上面的哈希函数来映射，但是如果我们存的是字符串或自定义类型的数据时，问题就来了，我们如何用除留余数法来计算呢？字符串和自定义类型不可以取模。

我们可以使用仿函数，如果是整型就返回整型，如果是字符串或自定义类型，就将其转换成整型再返回：

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

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

二、unordered_map和unordered_set的模拟实现

底层哈希桶：

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

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

namespace hash_bucket//拉链法——哈希桶
{

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

		T _data;
		HashNode<T>* _next;
	};

	template<class K, class T, class KofT, class HashFunc>
	class HashTable;//声明一下

	template<class K, class T, class Ref, class Ptr, class KofT, class HashFunc = DefaultHashFunc<K>>
	struct __HT_Iterator
	{
		typedef HashNode<T> Node;
		typedef __HT_Iterator<K, T, Ref, Ptr, KofT, HashFunc> Self;
		typedef __HT_Iterator<K, T, T&, T*, KofT, HashFunc> Iterator;


		__HT_Iterator(Node* node, const HashTable<K, T, KofT, HashFunc>* pht)
			:_node(node)
			,_pht(pht)//_pht为const修饰的指针
		{}

		//当此时这个类是普通迭代器类时，这个函数为拷贝构造
		//当此时这个类是const迭代器类时，这个函数为构造
		__HT_Iterator(const Iterator& it)
			:_node(it._node)
			,_pht(it._pht)
		{}


		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

		Self operator++()
		{
			
			//走这个桶里的下一个节点
			if (_node->_next)
			{
				_node = _node->_next;
			}
			//找其他桶
			else
			{
				KofT kot;
				HashFunc ht;
				size_t hashi = ht(kot(_node->_data)) % _pht->_table.size();
				++hashi;//找下一个桶
				while (hashi < _pht->_table.size())
				{
					if (_pht->_table[hashi])
					{
						_node = _pht->_table[hashi];
						return *this;
					}
					else
					{
						++hashi;
					}
				}
				_node = nullptr;
			}
			return *this;
		}

		bool operator!=(const Self& it) const 
		{
			return _node != it._node;
		}
		bool operator==(const Self& it) const
		{
			return _node == it._node;
		}


		Node* _node;
		const HashTable<K, T, KofT, HashFunc>* _pht;

	};

	template<class K, class T, class KofT, class HashFunc = DefaultHashFunc<K>>
	class HashTable
	{
		//友元声明
		template<class K, class T, class Ref, class Ptr, class KofT, class HashFunc>
		friend struct __HT_Iterator; 

		typedef HashNode<T> Node;
	public:
		typedef __HT_Iterator<K, T, T&, T*, KofT, HashFunc> iterator;
		typedef __HT_Iterator<K, T, const T&, const T*, KofT, HashFunc> const_iterator;


		iterator begin()
		{
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				if (cur)
					return iterator(cur, this);
			}
			return iterator(nullptr, this);
		}

		iterator end()
		{
			return iterator(nullptr, this);
		}

		const_iterator begin() const
		{
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				if (cur)
					return const_iterator(cur, this);
			}
			return const_iterator(nullptr, this);
		}

		const_iterator end() const
		{
			return const_iterator(nullptr, this);//这里的this是const修饰的，所以上面的迭代器里的构造的哈希表参数要设置成const
		}

		HashTable()
		{
			_table.resize(10, nullptr);
		}

		~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;
			}
			_n = 0;
		}

		pair<iterator, bool> insert(const T& data)
		{
			KofT kot;
			//检查是否已经存在
			iterator it = Find(kot(data));
			if (it != end())//找到了就返回此刻的pair
				return make_pair(it ,false);
			HashFunc ht;
			size_t fac = (double)_n / _table.size();//负载因子
			if (fac >= 1)//扩容
			{
				size_t newcapacity = _table.size() * 2;
				HashTable<K, T, KofT> newht;
				newht._table.resize(newcapacity, nullptr);
				//遍历旧的，链入新的
				for (int i = 0; i < _table.size(); i++)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = ht(kot(cur->_data)) % newcapacity;
						
						//头插
						cur->_next = newht._table[hashi];
						newht._table[hashi] = cur;

						cur = next;
					}
					_table[i] = nullptr;//这里必须要置空，否则不能释放
				}
				_table.swap(newht._table);
			}
			//头插
			Node* newnode = new Node(data);
			size_t hashi = ht(kot(data)) % _table.size();//找第几个桶

			newnode->_next = _table[hashi];
			_table[hashi] = newnode;

			_n++;

			return make_pair(iterator(newnode, this), true);
		}

		iterator Find(const K& key)
		{
			KofT kot;
			HashFunc ht;
			size_t hashi = ht(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur, this);
				}
				cur = cur->_next;
			}
			return end();
		}

		bool Erase(const K& key)
		{
			KofT kot;
			HashFunc ht;
			size_t hashi = ht(key) % _table.size();
			Node* prev = nullptr;
			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					_n--;
					return true;

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

		void Print()
		{
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				printf("[%d] : ", i);
				while (cur)
				{
					cout << "(" << cur->_kv.first << ":" << cur->_kv.second << ")" << "->";
					cur = cur->_next;
				}
				cout << "NULL" << endl;
			}
			cout << endl;
		}

		size_t count(const K& key)
		{
			if (Find(key) != end())
				return 1;
			else
				return 0;
		}
		size_t size()
		{
			return _n;
		}

		bool empty()
		{
			return _n == 0;
		}

	private:
		vector<Node*> _table;
		size_t _n = 0;//存放有效数据的个数
	};
}

封装unordered_map和unordered_set

template<class K, class V>
struct mapKofT
{
	K operator()(const pair<K, V>& kv)
	{
		return kv.first;
	}
};

template<class K, class V>
class Unordered_map
{
public:
	typedef typename hash_bucket::HashTable<K, pair<const K, V>, mapKofT<K, V>>::iterator iterator;
	typedef typename hash_bucket::HashTable<K, pair<const K, V>, mapKofT<K, V>>::const_iterator const_iterator;

	pair<iterator, bool> insert(const pair<K, V>& kv)
	{
		return _ht.insert(kv);
	}

	V& operator[](const K& key)
	{
		return _ht.insert(make_pair(key, V())).first->second;
	}
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}

	iterator find(const K& key)
	{
		return _ht.Find(key);
	}

	size_t count(const K& key)
	{
		return _ht.count(key);
	}
	size_t size()
	{
		return _ht.size();
	}
	bool empty()
	{
		return _ht.empty();
	}

	iterator begin()
	{
		return _ht.begin();
	}

	iterator end()
	{
		return _ht.end();
	}
	const_iterator begin() const
	{
		return _ht.begin();
	}

	const_iterator end() const
	{
		return _ht.end();
	}

private:
	hash_bucket::HashTable<K, pair<const K, V>, mapKofT<K, V>> _ht;
};
template<class K>
struct setKofT
{
	K operator()(const K& key)
	{
		return key;
	}
};

template<class K>
class Unordered_set
{
public:
	typedef typename hash_bucket::HashTable<K, K, setKofT<K>>::const_iterator iterator;
	typedef typename hash_bucket::HashTable<K, K, setKofT<K>>::const_iterator const_iterator;

	pair<iterator, bool> insert(const K& key)
	{
		return _ht.insert(key);
	}
	
	bool Erase(const K& key)
	{
		return _ht.Erase(key);
	}
	size_t size()
	{
		return _ht.size();
	}
	bool empty()
	{
		return _ht.empty();
	}
	size_t count(const K& key)
	{
		return _ht.count(key);
	}
	iterator find(const K& key)
	{
		return _ht.Find(key);
	}

	iterator begin() const
	{
		return _ht.begin();
	}
 	iterator end() const
	{
		return _ht.end();
	}

private:
	hash_bucket::HashTable<K, K, setKofT<K>> _ht;
};

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

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

相关文章

十二、Django之模板的继承+用户列表

十二、Django之模板的继承+用户列表

模板的继承 新建layout.html&#xff1a; {% load static %} <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title><link rel"stylesheet" href"{% static plugins…
阅读更多...
【功能设计】应用集成平台token授权接入

【功能设计】应用集成平台token授权接入

文章目录 IPass应用集成平台token授权接入1.接入流程图&#xff1a;2.功能设计&#xff1a;3.测试要点&#xff1a; IPass应用集成平台token授权接入 1.接入流程图&#xff1a; 功能业务流程描述&#xff1a; a.调用方从redis获取应用集成平台授权token b.如果没有拿到&…
阅读更多...
[linux] SFTP文件传输基本命令 --- xshell 直接上传文件

[linux] SFTP文件传输基本命令 --- xshell 直接上传文件

2.sftp - 上传文件&#xff1a;如果上传/下载的是文件夹, 在put/get命令后加上-r参数即可。 上传文件&#xff1a; 把本地服务器的/www/wwwroot目录下面的study.log文件上传到远程服务器的/www/server目录下。 sftp> lcd /www/wwwroot sftp> put study.log /www/server…
阅读更多...
数据结构与算法-顺序表

数据结构与算法-顺序表

数据结构与算法 &#x1f388;1.线性表&#x1f50e;1.1基本操作&#x1f50e;1.2线性表的存储结构 &#x1f388;2.线性表的顺序表示和实现&#x1f50e;2.1线性表的顺序存储表示&#x1f52d;2.1.1静态顺序表&#x1f52d;2.1.2动态顺序表 &#x1f50e;2.2顺序表基本操作的实…
阅读更多...
C/C++/VS2022/指针/数组 调试出现debug

C/C++/VS2022/指针/数组 调试出现debug

这个情况就很难受&#xff0c;编译没错&#xff0c;但是运行出现问题了&#xff0c;如果点击中止&#xff08;重试、忽略&#xff09;下一次运行还是会出现&#xff0c;看了显示的大致意思是在数组arry上出现了什么错误&#xff0c;经过检查发现&#xff0c;原来是数组在数入时…
阅读更多...
李沐深度学习记录2：10多层感知机

李沐深度学习记录2：10多层感知机

一.简要知识记录 x.numel()&#xff1a;看向量或矩阵里元素个数 A.sum()&#xff1a;向量或矩阵求和&#xff0c;axis参数可对某维度求和&#xff0c;keepdims参数设置是否保持维度不变 A.cumsum&#xff1a;axis参数设置沿某一维度计算矩阵累计和x*y:向量的按元素乘法 torch.…
阅读更多...
【Golang】并发

【Golang】并发

并发 有人把Go语言比作 21 世纪的C语言 第一是因为Go语言设计简单 第二则是因为 21 世纪最重要的就是并发程序设计&#xff0c;而 Go 从语言层面就支持并发。同时实现了自动垃圾回收机制 先来了解一些概念&#xff1a; 进程/线程 进程是程序在操作系统中的一次执行过程&#…
阅读更多...
MySQL锁的详细讲解（全局锁、表级锁、行级锁）

MySQL锁的详细讲解（全局锁、表级锁、行级锁）

# 概述 # 全局锁 # 表级锁 表锁 元数据锁 假如有客户端1、客户端2&#xff0c; 客户端1&#xff0c;执行begin命令开启了事务 客户端1没有执行读写语句&#xff0c;这时&#xff0c;客户端执行查看元数据锁的命令&#xff0c;查看到没有加到元数据锁当客户端1执行select读操作…
阅读更多...
Ubuntu使用cmake和vscode开发自己的项目

Ubuntu使用cmake和vscode开发自己的项目

创建文件夹 mkdir my_proj 继续创建include 和 src文件夹&#xff0c;形成如下的目录结构 用vscode打开项目 创建add.h #ifndef ADD_H #define ADD_Hint add(int numA, int numB);#endif add.cpp #include "add.h"int add(int numA, int numB) {return numA nu…
阅读更多...
RDP协议流程详解（一）Connection Initiation阶段

RDP协议流程详解（一）Connection Initiation阶段

Connetction Initiation是RDP连接的第一个阶段&#xff0c;具体包含两个消息RDP Negotiation Request和RDP Negotiation Response&#xff0c;下面结合协议数据包详细分析。 &#xff08;1&#xff09;RDP Negotiation Request 从数据包可以清晰看到此时的协议栈依次是TCP-TPKT…
阅读更多...
波奇学C++:map和set

波奇学C++:map和set

Set的底层是红黑树&#xff0c;红黑树是一种搜索二叉树。 Set的优势在于搜索速度上&#xff0c;搜索key值的时间赋值度是logn。 Set可以实现去重排序的操作&#xff0c;已有的值不再重复插入&#xff0c;插入的数据自动排序 和其他数据结构一样set支出insert,erase,find等操…
阅读更多...
ctfshow web入门 php特性 web126-web130

ctfshow web入门 php特性 web126-web130

1.web126 和前面一样的 payload&#xff1a; get: a1fl0gflag_give_me post: CTF_SHOW&CTF[SHOW.COM&funparse_str($a[1]) 或 get: ?$fl0gflag_give_me post:CTF_SHOW&CTF[SHOW.COM&funassert($a[0]) assert($a[0]) 是把fl0g赋值为flag_give_me $a[0]是当前…
阅读更多...
​【Java】面向对象程序设计 课程笔记 面向对象基础

​【Java】面向对象程序设计 课程笔记 面向对象基础

&#x1f680;Write In Front&#x1f680; &#x1f4dd;个人主页&#xff1a;令夏二十三 &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd; &#x1f4e3;系列专栏&#xff1a;Java &#x1f4ac;总结&#xff1a;希望你看完之后&#xff0c;能对你有…
阅读更多...
数仓使用SQL脚本在数据库中添加初始数据示例

数仓使用SQL脚本在数据库中添加初始数据示例

文章目录 需要在虚拟机上开启数据库 点击确定后&#xff0c;可以点开这个连接&#xff0c;查看数据库信息 运行 init_mysql.sql 创建mall 数据库 -- 设置sql_mode set sql_mode NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES;-- 创建数据库mall create database mall;-- 切换数…
阅读更多...
FL水果21编曲宿主软件最新版本更新下载使用教程

FL水果21编曲宿主软件最新版本更新下载使用教程

rt&#xff0c;楼主受术曲和jpop等影响&#xff0c;重新回到了FL编曲圈中来。目前&#xff0c;正在整理一份关于FL界面、快捷键操作、插件音源、风格制作等汇总笔记&#xff0c;笔记内容来源于来自于网上和个人的编曲经历的理解而成&#xff0c;欢迎大家为笔记的制作与完善提供…
阅读更多...
【代码阅读笔记】yolov5 rknn模型部署

【代码阅读笔记】yolov5 rknn模型部署

一、main函数思路 二、值得学习的地方 1、关注yolov5检测流程 2、其中几个重要的结构体 typedef struct {int left;int right;int top;int bottom; } YOLOV5_BOX_RECT; // box坐标信息typedef struct {char name[YOLOV5_NAME_MAX_SIZE];int class_index;YOLOV5_BOX_RECT box…
阅读更多...
【重拾计划】深搜广搜 | luogu P1135 奇怪的电梯

【重拾计划】深搜广搜 | luogu P1135 奇怪的电梯

luogu P1135 奇怪的电梯 题目描述方法一 : 深搜dfs方法二&#xff1a;广搜bfs其他解法 题目描述 luogu P1135 奇怪的电梯 方法一 : 深搜dfs 从点A出发&#xff0c;找到符合条件的点一直往下搜即可 代码实现如下&#xff1a; #include<iostream> #include<cstdio…
阅读更多...
PS 图层剪贴蒙版使用方法

PS 图层剪贴蒙版使用方法

好 我们先打开PS软件 后面我们需要接触图框工具 在学习图框工具之前 先要掌握剪贴蒙版 这里 我们先点击左上角文件 然后选择新建 我们先新建一个画布出来 然后 我们点击 箭头指向处 新建一个空白图层 点击之后 会就多出一个空白图层 我们在这里 找到 矩形选框工具 然后 …
阅读更多...
windows环境下使用mmdetection+mmdeploy训练自定义数据集并转成onnx格式部署

windows环境下使用mmdetection+mmdeploy训练自定义数据集并转成onnx格式部署

目录 实验环境安装conda创建虚拟环境安装pytorch使用 MIM 安装 MMEngine 和 MMCV安装 MMDetection准备自定义数据集修改配置信息开始训练模型转换与推理 实验环境 windows10python&#xff1a;3.8pytorch :1.8.1cuda&#xff1a;11.1mmdet&#xff1a;3.1.0mmcv&#xff1a;2.…
阅读更多...
想要精通算法和SQL的成长之路 - 验证二叉树

想要精通算法和SQL的成长之路 - 验证二叉树

想要精通算法和SQL的成长之路 - 验证二叉树 前言一. 验证二叉树1.1 并查集1.2 入度以及边数检查 前言 想要精通算法和SQL的成长之路 - 系列导航 并查集的运用 一. 验证二叉树 原题链接 思路如下&#xff1a; 对于一颗二叉树&#xff0c;我们需要做哪些校验&#xff1f; 首先…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023