unordered_map&set

最新推荐文章于 2024-06-17 22:13:25 发布
最新推荐文章于 2024-06-17 22:13:25 发布
阅读量1k 收藏 14
点赞数 31
分类专栏： C++ 文章标签： c++ 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81451574/article/details/139219182
版权

文章目录


前言：unordered_map & unordered_set 是一对关联式容器，与map，set功能上类似，分别是KV，K的模型，其底层的实现是哈希表，所不同的是里边的存储是无序的

Ⅰ. 使用

a. unordered_map

函数名称函数功能
empty()返回表是否为空
size()返回存表中数据的个数
[ K ] & at( K )返回对应的V
find(K)返回迭代器
count(K)返回表中K的个数
insert({K，V})插入一个键值对，返回一个pair<Iterator,bool>
erase(K)删除KV并返回删除K前K的个数
void test_unordered_map1()
{
	unordered_map<int, int> um;
	
	// 1.有名对象构造
	pair<int, int> e(1, 1);
	um.insert(e);
	// 2.匿名对象构造
	um.insert(pair<int,int>(2,2));
	// 3.仿函数构造
	um.insert(make_pair(3, 3));
	// 4.多参数的隐式类型转换构造
	um.insert({ 4,4 });
	
	// 迭代器遍历
	unordered_map<int, int>::iterator it = um.begin();
	while (it != um.end())
	{
		cout << it->first << " " << it->second << endl;
	}
	cout << endl;
	// 迭代器遍历
	for(auto e: um)
	{
		cout<<e.first<<" "<<e.second()<<endl;
	}
}

void test_unordered_map2()
{
	// 最厉害的为属 [ ]
	unordered_map<string, int> um;
	string s[] = { "安徽","河北","河南","河南","广东","河南","河南","广东" ,"河南","河南","广东" };
	
	for (auto& str : s)
	{
		um[str]++;
	}
	// 这样就把城市的总次数统计出来了
	for (auto e : um)
	{
		cout << e.first << " " << e.second << endl;
	}
}

b. unordered_set

unordered_set的使用和unordere_map的使用基本上类似，感兴趣的可以去看一下文档

C++文档unordered_set
C++文档unordered_map

Ⅱ. 哈希表

哈希表底层就是vector实现的
1. 每个值里边存放一个 pair，还有一个表示 状态信息 的 枚举常量，就是线性探测哈希表
2. vector里边每个值都挂一个 链表 ，就是哈希桶
3. 有了红黑树，为什么还要有哈希表呢？因为哈希表的 插入，删除，查找 三个操作在理论上都是O(1) 的时间复杂度
（数据碰撞除外），因为采用了值与位置的映射的存储关系，而红黑树的插入，查找，删除 理论上是O(logN) （不考
虑旋转变色）

a. 闭散列：线性探测

1.仿函数，2.插入，3.删除，4.查找，5.扩容

  1. 仿函数 ：将一个对象的所有成员进行转换，转为size_t类型，这样方便进行下标的取模操作进而进行哈希映射，比如string 每个字符串ASC码相加返回，负数直接转化为无符号的整形就变为了整数，再比如一个Person类，可以对每个人的名字，身份证，年龄整合返回，这样的两个人对应数组的映射下标的很小概率相同

  2. 插入：将所给的K值与数组下标产生映射关系，将此值存入到此下标处，一般K都是字符串类，整数，都是整形家族的类型，此时就可以使用 %，用仿函数 将此K转为 size_t 类型，然后模上表的长度，找到映射位置，也有可能此处的位置被占，比如 19 9 都去 模表长为10 的位置，那么此时就需要从此下标处开始继续往后找到第一个没有被占用的下标位置，将值放入，并将状态设置为EXIST

  3. 查找：先使用仿函数 映射出下标，可能该处就是所要查找的值 直接返回，要么就进行线性探测继续往后找，状态为空，找不到，状态不为空先判断，判断一下是否是 存在状态 且 里边的值 为所要查找的值，若是，找到了返回，若不是，继续往后找

  4. 删除：调用查找函数，用函数调用返回的指针，将此处的状态改为删除状态，里边的数据不用抹除，因为我们进行的各种操作先判断的就是状态，而且如果抹除该设为多少呢？（抹除为几都不行，因为你下次插入的可能就是这个值）

  5. 扩容机制：当_n 除 表的长度超过 0.7的时候就开始扩容，大于0.7下一次的插入很容易造成哈希碰撞，小与0.7空间利用不充分；开一个新的vector，大小设为原来的二倍，将状态为存在的值，重新取模进行新表的映射，然后于旧的vector交换

#include<vector>

enum STate
{
	EMPTY,
	EXIST,
	DELETE,
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	STate _state = EXIST;
};

template<class K>
struct Hash
{
	size_t operator()(const K& k)
	{
		return (size_t)k;
	}
}; 
template<>
struct Hash<string>
{
	size_t operator()(const string& s)
	{
		size_t ret = 0;
		for (auto ch : s)
			ret = ret * 131 + ch;
		return ret;
	}
};

template<class K,class V,class Hash = Hash<K>>
class HashTable
{
public:
	HashTable(size_t n = 10)
	{
		_tables.resize(n);
	}

	bool insert(const pair<K, V>& kv)
	{
		if(find(kv.first))
			return false;
		
		if (_n * 10 / _tables.size() >= 7)
		{
			HashTable<K, V, Hash> newhash(_tables.size() * 2);
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[hashi]._state == EXIST)
					newhash.insert(_tables[hashi]._kv);
			}
			_tables.swap(newhash._tables);
		}

		Hash hs;
		size_t hashi = hs(kv.first) % _tables.size();
		while (_tables[hashi]._state == EXIST)
		{
			++hashi;
			hashi %= _tables.size();
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}

	HashData<K,V>* find(const K& k)
	{
		Hash hs;
		size_t hashi = hs(k) % _tables.size();
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hahsi]._kv.first == k && _tables[hashi]._state == EXIST)
			{
				return &_tables[hashi];
			}
			else
			{
				++hashi;
				hashi %= _tables.size();
			}
		}

		return nullptr;
	}
	bool erase(const K& k)
	{
		HashData<K, V>* ret = find(k);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	vector<HashData> _tables;
	size_t _n = 0;
};

b. 开散列：哈希桶

1.仿函数，2.插入，3.删除，4.查找，5.扩容

  1. 仿函数：同线性探测

  2. 插入：用仿函数映射出下标，找到该链表，对链表进行头插（可随便插入，但是头插的效率高）

  3. 删除：用仿函数先映射出下标，找到处于哪个位置的链表，遍历该链表进行此节点的前后链接关系

  4. 查找：用仿函数映射出下标，接下来进行链表的查找

  5. 扩容机制：当所有节点的个数总和 与 vector的大小一样时（负载因子为1），就开始扩容，将每个节点取下来重新映射关系，因为 vector 的空间大小 增大，所以要%一个新表的长度

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 Mod = KOfMod<K>>
class Hash
{
	typedef HashNode<K, V> Node;
public:
	Hash(size_t n = 10)
	{
		_v.resize(n, nullptr);
	}

	~Hash()
	{
		for (int i = 0; i < _v.size(); i++)
		{
			Node* cur = _v[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_v[i] = nullptr;
		}
	}

	bool insert(const pair<K, V>& kv)
	{
		if (find(kv.first)) 
			return false;

		Mod mod;

		if (_n == _v.size())
		{
			vector<Node*> newv(_n * 2, nullptr);
			for (int i = 0; i < _n; i++)
			{
				Node* cur = _v[i];
				while (cur)
				{
					Node* next = cur->_next;
					size_t hashi = mod(cur->_kv.first) % newv.size();
					cur->_next = newv[hashi];
					newv[hashi] = cur;
					
					cur = next;
				}
				_v[i] = nullptr;
			}
			_v.swap(newv);
		}

		size_t hashi = mod(kv.first) % _v.size();
		Node* newnode = new Node(kv);
		newnode->_next = _v[hashi];
		_v[hashi] = newnode;
		_n++;
		return true;
	}

	Node* find(const K& k)
	{
		Mod mod;
		size_t hashi = mod(k) % _v.size();
		Node* cur = _v[hashi];
		while (cur)
		{
			if (cur->_kv.first == k)
			{
				return cur;
			}
			cur = cur->_next;
		}
		return nullptr;
	}

	bool erase(const K& k)
	{
		Mod mod;
		size_t hashi = mod(k) % _v.size();
		Node* prev = nullptr;
		Node* cur = _v[hashi];
		while (cur)
		{
			if (cur->_kv.first == k)
			{
				Node* next = cur->_next;
				if (prev == nullptr)
				{
					_v[hashi] = next;
				}
				else
				{
					prev->_next = next;
				}
				delete cur;
				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}

private:
	vector<Node*> _v;
	size_t _n = 0;
};

Ⅲ. 封装实现

a. HashTable的封装完善

#pragma once

#include<vector>
#include<string>

namespace hash_bucket
{
	template<class K>
	struct Hash
	{
		size_t operator()(const K& k)
		{
			return (size_t)k;
		}
	};

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

	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _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 __HashTable_Iterator
	{
		typedef HashNode<T> Node;
		typedef __HashTable_Iterator<K, T,Ref,Ptr, KeyOfT, Hash> Self;
		
		Node* _node;
		const HashTable<K, T, KeyOfT, Hash>* _pht;

		__HashTable_Iterator(Node* node,const HashTable<K, T, KeyOfT, Hash>*pht)
			:_node(node),_pht(pht)
		{}
		
		Ref operator*()
		{
			return _node->_data;
		}

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

		Self& operator++()
		{
			KeyOfT kot;
			Hash hs;

			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();
				++hashi;
				for (; hashi < _pht->_tables.size(); hashi++)
				{
					Node* cur = _pht->_tables[hashi];
					if (cur)
					{
						_node = cur;
						break;
					}
				}
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}

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

	template<class K,class T,class KeyOfT, class Hash>
	class HashTable
	{
		typedef HashNode<T> Node;
	public:
		template<class K, class T,class Ref,class Ptr, class KeyOfT, class Hash>
		friend struct __HashTable_Iterator;// 将迭代器设为 友元类，方便找位于表中的位置 实现++
		
		typedef __HashTable_Iterator<K, T, T&, T*, KeyOfT, Hash> iterator;
		typedef __HashTable_Iterator<K, T,const T&,const T*, KeyOfT, Hash> const_iterator;

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

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

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

		const_iterator end() const
		{
			return const_iterator(nullptr, this);
		}

		HashTable(size_t n = 10)
		{
			_tables.resize(n, nullptr);
		}

		pair<iterator,bool> insert(const T& data)
		{
			KeyOfT kot;
			iterator ret = find(kot(data));
			if (ret!=end())
				return make_pair(ret,false);

			Hash hs;
			if (_n == _tables.size())
			{
				std::vector<Node*> newtables(_tables.size() * 2, nullptr);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						
						size_t hashi = hs(kot(data)) % newtables.size();
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;
						
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtables);
			}

			size_t hashi = hs(kot(data)) % _tables.size();
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return make_pair(iterator(newnode,this), true);
		}

		iterator find(const K& k)
		{
			KeyOfT kot;
			Hash hs;
			size_t hashi = hs(k) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == k)
				{
					return iterator(cur,this);
				}
				cur = cur->_next;
			}
			return end();
		}

		bool erase(const K& k)
		{
			KeyOfT kot;
			Hash hs;
			size_t hashi = hs(k) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == k)
				{
					Node* next = cur->_next;
					if (prev == nullptr)
					{
						_tables[hashi] = next;
					}
					else
					{
						prev->_next = next;
					}
					delete cur;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

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

b. unordered_set

#pragma once

#include"HashTable.h"
namespace zy
{
	template<class K>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K,const K, SetKeyOfT, hash_bucket::Hash<K>>::iterator iterator;
		typedef typename hash_bucket::HashTable<K,const K, SetKeyOfT, hash_bucket::Hash<K>>::const_iterator const_iterator;

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

		pair<iterator,bool> insert(const K& k)
		{
			return _hs.insert(k);
		}
		iterator find(const K& k)
		{
			return _hs.find(k);
		}
		bool erase(const K& k)
		{
			return _hs.erase(k);
		}
	private:
		hash_bucket::HashTable<K,const K,SetKeyOfT,hash_bucket::Hash<K>> _hs;
	};

	void test_unordered_set1()
	{
		unordered_set<int> s;
		s.insert(1001);
		s.insert(11);
		s.insert(12);
		s.insert(23);
	}
	void test_unordered_set2()
	{
		string s[] = { "sort","left","right" };
		unordered_set<string> st;
		for (auto e : s)
		{
			st.insert(e);
		}
		st.insert("parent");
		st.insert( "parent");
	}
	void test_unordered_set3()
	{
		unordered_set<int> s;
		s.insert(1);
		s.insert(12);
		s.insert(13);
		s.insert(21);

		unordered_set<int>::iterator cit1 = s.begin();
		unordered_set<int>::const_iterator cit2 = s.begin();
	}
}

c. unordered_map

#pragma once

#include"HashTable.h"
namespace zy
{
	template<class K , class V>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, hash_bucket::Hash<K>>::iterator iterator;
		typedef typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, hash_bucket::Hash<K>>::const_iterator const_iterator;

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

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _hs.insert(kv);
		}
		iterator find(const K& k)
		{
			return _hs.find(k);
		}
		bool erase(const K& k)
		{
			return _hs.erase(k);
		}
		V& operator[](const K& k)
		{
			pair<iterator, bool> ret = _hs.insert(make_pair(k, V()));
			return ret.first->second;
		}

	private:
		hash_bucket::HashTable<K, std::pair<const K, V>,MapKeyOfT,hash_bucket::Hash<K>> _hs;
	};

	void test_unordered_map1()
	{
		int a[] = { 10001,12,13,25 };
		unordered_map<int, int> m;
		for (auto e : a)
		{
			m.insert({ e,e });
		}
		m.insert({ 12,12 });

		for (auto e : m)
		{
			cout << e.first << " " << e.second << endl;
		}
	}
	void test_unordered_map2()
	{
		string s[] = { "sort","left","right" };
		unordered_map<string, int> m;
		for (auto e : s)
		{
			m.insert({ e,1 });
		}
		m.insert({ "parent",1 });
		m.insert({ "parent",1});
		for (auto e : m)
		{
			cout << e.first << " " << e.second << endl;
		}
	}

	void func(const unordered_map<int, int>& m)
	{
		unordered_map<int, int>::const_iterator it = m.begin();
		while (it != m.end())
		{
			cout << it->first << " " << it->second << endl;
			++it;
		}
	}

	void test_unordered_map3()
	{
		int a[] = { 10001,12,13,25 };
		unordered_map<int, int> m;
		for (auto e : a)
		{
			m.insert({ e,e });
		}
		m.insert({ 12,12 });
		func(m);
	}

	void test_unordered_map4()
	{
		string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };
		unordered_map<string, int> countMap;
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		unordered_map<string, int>::iterator it = countMap.begin();
		while (it != countMap.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}
	}
}
山水未央
关注
  • 31
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【STL】unordered_map&set
__皮娃__的博客
04-08 430
【STL】unordered_map&set(Useless) What You Should KnowMainHow to Use It遍历How to Kill It参考资料 一般来说，如何优化时间复杂度？把map&set改成unordered_map&set。 (Useless) What You Should Know template<typename T...
unordered_flat_set:C ++连续内存哈希容器。-开源
04-25
连续内存开放式寻址/封闭式散列，带有线性探测，容器。 基本上是unordered_set，unordered_map，unordered_multiset和unordered_multimap，但具有类似内存分配的向量。
C++ unordered_map&set
Han同学
01-31 881
unordered_map&set
c++ map与unordered_map区别及使用
热门推荐
别说话写代码的博客
12-01 26万+
转自：https://blog.csdn.net/BillCYJ/article/details/78985895 需要引入的头文件不同 map: #include &lt; map &gt; unordered_map: #include &lt; unordered_map &gt; 内部实现机理不同 map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二...
c++中 unordered_map 与 unordered_set 用法指南
小金牛来了
06-01 1103
c++中 unordered_map 与 unordered_set 用法指南
unordered_map和unordered_set
m0_69323023的博客
02-04 1547
unordered_map和unordered_set
C++之unordered_map/set的使用
ZZY5707的博客
11-24 944
前面我们已经学习了STL中底层为红黑树结构的一系列关联式容器——set/multiset 和 map/multimap(C++98).
C++STL详解（六）unordered_set&unordered_map介绍
Tau_Ceti的博客
09-17 967
详解unordered_set&unordered_map
C++进阶--unordered_set、unordered_map的介绍和使用
sushang的博客
01-15 3109
1.unordered_set是不按特定顺序存储键值的关联式容器，其允许通过键值快速的索引到对应的元素。2.在unordered_set中，元素的值同时也是唯一的标识它的key。3.在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的key，unordered_set将相同哈希值的键值放在相同的桶中。4.unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。5.它的迭代器至少是前向迭代器。
C++ unordered_map和unordered_set的使用
qq_61635026的博客
09-16 2693
unordered_map在线文档说明unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
unordered_map和unordered_set的模拟实现
01-20
unordered_map和unordered_set的模拟实现 （一）哈希表的特性及概念 定义： 哈希表（Hash table，也叫散列表），是根据关键字值（key,value）直接进行访问的数据结构。也就是说，它通过把关键字映射到表中一个位置来...
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
parallel-hashmap:一系列仅标头，非常快速且对内存友好的hashmap和btree容器
04-28
替换std::unordered_map ， std::unordered_set ， std::map和std::set 需要具有C ++ 11支持的编译器，提供了C ++ 14和C ++ 17 API（例如try_emplace ） 非常高效，比编译器的无序映射/集合或Boost或显着更快 ...
算法（42）-数组等值切割-前缀累加和-哈希表Map-set版-C++
01-07
题目：给定正整数，返回该数组能不能分成4... set和map两种哈希表类型。其实没啥本质差别。 1.unordered_set版   bool canSplits_set(vci arr) { if (arr.size() < 7) { return false; } unordered_set m
C++ day3
最新发布
2301_81402136的博客
06-17 278
【代码】C++ day3。
C的I/O操作
weidl001的博客
06-17 742
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 348
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
11.5.k8s中pod的调度-cordon，drain，delete
qq_22321199的专栏
06-17 585
-ignore-daemonsets #daemonset资源不能被驱逐，需要排除，加这个选项参数排除；--delete-emptydir-data #如果无法驱逐成功，再加这个参数；
unordered_map与unordered_set
08-12
unordered_map与unordered_set有什么区别？ 回答: unordered_map和unordered_set都是关联式容器，类似于键值对 (key-value) 的模型。它们的底层实现方式不同，unordered_map使用哈希表作为底层数据结构，而unordered...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值