【C++】哈希、unordered_map/unordered_set

已于 2024-05-07 22:39:36 修改
阅读量793 收藏 25
点赞数 30
文章标签： c++ 开发语言
于 2023-12-09 17:03:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63989073/article/details/134871885
版权

1.unordered系列容器

在c++11中，STL新提供了4个unordered系列的关联式容器，用于应对红黑树节点太多导致的查询效率不理想的问题，新增的容器使用方法与红黑树结构的关联式容器基本相同，只是底层结构不同。

1.1 unordered_map

1. unordered_map是存储键值对的关联式容器，可以使用key找到value。

2. 在unordered_map中，key是唯一的。

3. 在内部,unordered_map没有排序而是使用哈希将key映射到哈希桶中。

4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。

5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问 value。

6. 它的迭代器至少是前向迭代器。

1.2unordered_map的接口说明

1.2.1构造

构造不同格式的unordered_map对象

1.2.2 查询

返回key在哈希桶中的位置：

返回哈希桶中关键码为key的键值对的个数：

1.2.3迭代器

1.2.4元素访问

返回与key对应的value，key不存在会构造一个value默认值。

1.2.5 容量

检测容器是否为空：

查看容器有效数据的个数：

1.2.6 修改

插入：向容器中插入键值对

删除：删除容器中的键值对

清空：清空容器中有效元素个数

交换：交换两个容器中的元素

1.2.7 对哈希桶进行操作

桶计数：返回哈希桶中桶的总个数

桶中元素计数： 返回n号桶中有效元素的总个数

返回元素key所在的桶号

1.3 unordered_set

unordered_set的用法与set差不多，这里就略过了详细可以参考官方文档：unordered_set - C++ Reference (cplusplus.com)

2.底层结构

unordered系列的关联式容器使用了哈希结构以保证高效率。

2.1 哈希

顺序结构和平衡树中，key没有与它的存储位置进行映射，所以在查找一个元素时，需要拿key进行比较，他们效率分别是O(N)和O(log₂N)，搜索的效率取决于搜索过程中元素的比较次数。

如果能通过一个hash_func函数把key映射到某个位置，就可以很快找到key的位置。

当向该结构中插入元素时： 根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

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

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

例如：

一组数

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

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

但是这样做会出现问题。

2.2 哈希冲突

如果两个key%出来的值相同，他们就会映射到同一个地方，这样就会造成冲突,不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突 或哈希碰撞。要解决这样的问题就需要不同的哈希函数。

2.3 哈希函数

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

哈希函数设计原则：

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

域必须在0到m-1之间

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

哈希函数应该比较简单

常见哈希函数

1. 直接定址法--(常用)

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

优点：简单、均匀

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

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

2. 除留余数法--(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，

按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

3. 平方取中法

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；

再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4. 折叠法

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这

几部分叠加求和，并按散列表表长，取后几位作为散列地址。

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5. 随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中

random为随机数函数。

通常应用于关键字长度不等时采用此法

6. 数学分析法

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定

相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只

有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散

列地址。

2.4解决哈希冲突

解决哈希冲突一般有两总方式：开散列，闭散列。

2.4.1 闭散列

闭散列：闭散列也叫开放定值发，每当发生哈希冲突时，如果哈希表还没有被存满，就可以寻找新的空间，把key存到哈希冲突的“下一个“位置去。

        1.线性探测

当发生哈希冲突时，从发生冲突的下一个位置开始依次寻找一个空位置。

插入：通过哈希函数获取待插入元素在哈希表中的位置 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突， 使用线性探测找到下一个空位置，插入新元素。

删除：采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

线性探测的简单实现：

namespace open_addres
{
	enum status
	{
		EXIST,
		EMPTY,
		DELETE
	};


	template<class K,class V>
	struct HashData
	{
		HashData()
			:_s(EMPTY)
		{}
		pair<K, V> _kv;
		status _s;
	};

	


	template<class K, class V,class Hash = HashFunc<K>>
	class HashTable
	{
		
		typedef HashData<K, V> HashData;
	public:
		HashTable()
			:_n(0)
		{
			_table.resize(10);
		}
		bool insert(const pair<K,V>& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			
			if (_n * 10 / _table.size() >= 7)
			{
				HashTable<K,V> newt;
				newt._table.resize(_table.size() * 2);
				for (int i = 0; i < _table.size(); i++)
				{
					if (_table[i]._s == EXIST)
					{
						newt.insert(_table[i]._kv);
					}
				}
				_table.swap(newt._table);
			}

			Hash hf;
			size_t hashi = hf(kv.first) % _table.size();
			while(_table[hashi]._s == EXIST )
			{
				hashi++;
				hashi = hashi % _table.size();
			}

			_table[hashi]._kv = kv;

			_table[hashi]._s = EXIST;
			_n++;

			return true;

		}

		HashData* Find(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _table.size();
			while (_table[hashi]._s != EMPTY)
			{
				if (_table[hashi]._s == EXIST && key == _table[hashi]._kv.first)
				{
					return &_table[hashi];
				}
				hashi++;
				hashi = hashi % _table.size();
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashData* ret = Find(key);
			if (ret)
			{
				ret->_s = DELETE;
				--_n;
				return true;
			}
			return false;
		}
		const size_t size() 
		{
			return _n;
		}

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

		void Print()
		{
			for (int i = 0; i < _table.size(); i++)
			{
				if (_table[i]._s == EXIST)
				{
					
					cout << "[" << i << "]->" << _table[i]._kv.first << ":" << _table[i]._kv.second << endl;
				}
				else if (_table[i]._s == EMPTY)
				{
					printf("[%d]->\n", i);
				}
				else
				{
					printf("[%d]->D\n", i);
				}
			}

			cout << endl;
		}

	private:
		vector<HashData> _table;
		size_t _n;
	};
}

负载因子：

对于开放定值发，负载因子是非常重要的，要严格限制在0.8以下。负载因子越大说明表中存的数据越多，发生哈希冲突的概率越大，负载因子越低说明表中的数据越少，发生哈希冲突的概率越小。

线性探测优点：实现非常简单，

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

        2.二次探测

因为线性探测容易让数据堆积到一起，找空位的方式就是按顺序找，使用二次探测就能解决这个问题。

例如，哈希函数为 i = key % capacity。找下一个空位置的方法 为：H_i = (H_0 + i^2 )% m, 或者：H_i = (H_0 - i^2 )% m。其中：i = 1,2,3…， $H_0$是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表 的大小。

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

所以闭散列最大的缺陷就是空间利用率太低。

2.4.2 开散列

 1.开散列的概念

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

例如：

经过映射后：

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

  2。开散列的简单实现

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

	template<class K,class V, class hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_tables.resize(10);
		}
		~HashTable()
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		bool insert(const pair<K,V>& kv)
		{

			if (find(kv.first))
			{
				return false;
			}
			hash hf;
			if (_n == _tables.size())
			{
				
				/*size_t newsize = _tables.size() * 2;
				HashTable newhash;
				newhash._tables.resize(newsize);
				for (int i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						newhash.insert(cur->_kv);
						cur = cur->next;
					}
				}
				_tables.swap(newhash._tables);*/
				vector<Node*> newtable;
				newtable.resize(_tables.size() * 2, nullptr);
				for (int i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						size_t s = hf(cur->_kv.first) % newtable.size();
						cur->next = newtable[i];
						newtable[i] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

			size_t hashi = hf(kv.first) % _tables.size();

			Node* newnode = new Node(kv);

			newnode->next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
			
		}

		Node* find(const K& key) 
		{
			hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->next;
			}
			return nullptr;
		}
		bool erase(const K& key)
		{
			hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->next;
					}
					else
					{
						prev->next = cur->next;

					}
					delete cur;

					return true;
				}
				prev = cur;
				cur = cur->next;
			}
			return false;
			
		}
		
	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};
}

   3.这样还会出现一个问题，只能存储key为整形的元素，其他类型怎么解决？

拿string类型来举例，如果key的类型是string，可以通过不同的hashfunc来把key转化成整型

//整型数据就不需要转换
template<class T>
struct HashFunc
{
	size_t operator()(const T& data)
	{
		return (size_t)data;
	}
};
//转换string类型
template<>
struct HashFunc<string>
{
	size_t operator()(const string& data)
	{
		int sum = 0;
		for (auto& i : data)
		{
			sum += i;
		}
		return sum * 31;

	}
};

2.4.3 开散列与闭散列的比较

链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

3、简单模拟实现

3.1 改造哈希表

增加模版参数，增加迭代器，能通过key获取val

#pragma once

#include<vector>


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

template<>
struct HashFunc<string>
{
	size_t operator()(const string& data)
	{
		int sum = 0;
		for (auto& i : data)
		{
			sum += i;
		}
		return sum * 31;

	}
};

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



template<class K, class T, class KofT, class hash>
class HashTable;

template<class K, class T, class Ref, class Ptr, class KofT, class hash >
struct __HTIterator
{
	typedef __HTIterator<K, T, Ref, Ptr, KofT, hash> self;
	typedef HashNode<T> node;
	node* _node;
	const HashTable<K, T, KofT, hash>* _pht;
	size_t _hashi;


	__HTIterator(node* node, HashTable<K, T, KofT, hash>* pht,size_t hashi)
		:_node(node)
		,_pht(pht)
		,_hashi(hashi)
	{}
	__HTIterator(node* node, const HashTable<K, T, KofT, hash>* pht, size_t hashi)
		:_node(node)
		, _pht(pht)
		, _hashi(hashi)
	{}
	self& operator++()
	{
		if (_node->next)
		{
			_node = _node->next;
		}
		else
		{
			++_hashi;
			while (_hashi < _pht->_tables.size())
			{
				if (_pht->_tables[_hashi])
				{
					_node = _pht->_tables[_hashi];
					break;
				}
				_hashi++;
			}
			if (_hashi == _pht->_tables.size())
			{
				_node = nullptr;
			}
		}
		return *this;
	}
	Ref operator*()
	{
		return _node->_data;
	}

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

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



	

	template<class K,class T, class KofT, class hash>
	class HashTable
	{
		typedef HashNode<T> Node;
		template<class K, class T, class Ref, class Ptr, class KofT, class hash>
		friend struct __HTIterator;

	public:
		typedef __HTIterator<K, T,T&, T*, KofT, hash> iterator;
		typedef __HTIterator<K, T, const T&, const T*, KofT, hash> const_iterator;


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

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

		const_iterator begin() const
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return const_iterator(_tables[i], this, i);
				}
			}
			return end();
		}
		const_iterator end() const
		{
			return const_iterator(nullptr, this, -1);
		}

		HashTable()
		{
			_tables.resize(10);
		}
		~HashTable()
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		pair<iterator,bool> insert(const T& data)
		{
			KofT kot;

			iterator it = find(kot(data));
			if (it != end())
			{
				return make_pair(it,false);
			}
			hash hf;
			
			if (_n == _tables.size())
			{
				
				vector<Node*> newtable;
				newtable.resize(_tables.size() * 2, nullptr);
				for (int i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						size_t s = hf(kot(cur->_data)) % newtable.size();
						cur->next = newtable[i];
						newtable[i] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

			size_t hashi = hf(kot(data)) % _tables.size();

			Node* newnode = new Node(data);

			newnode->next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return make_pair(iterator(newnode,this,hashi), true);
			
		}

		iterator find(const K& key) 
		{
			hash hf;
			KofT kot;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur,this,hashi);
				}
				cur = cur->next;
			}
			return end();
		}
		bool erase(const K& key)
		{
			hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->next;
					}
					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 < _tables.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);
		}
	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};

3.2 unordered_map

#pragma once
#include"Hash_Table.h"


namespace crin
{
	template<class K,class V, class hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKofT
		{
			const K& operator()(const pair<K,V>& kv)
			{
				return kv.first;
			}
		};
	public:

		typedef typename HashTable<K, pair<const K, V>, MapKofT,hash>::iterator iterator;
		


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

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

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

	private:
		HashTable<K, pair<const K, V>,MapKofT,hash> _ht;

	};
}

3.3 unordered_set

#pragma once
#include"Hash_Table.h"

namespace crin
{
	template<class K,class hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKofT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:

		typedef typename HashTable<K, K, SetKofT,hash>::const_iterator iterator;
		typedef typename HashTable<K, K, SetKofT, hash>::const_iterator const_iterator;


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

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

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

		pair<const_iterator,bool> insert(const K& key)
		{
			auto ret =  _ht.insert(key);
			return pair<const_iterator, bool>(iterator(ret.first._node,ret.first._pht,ret.first._hashi),ret.second);
			
		}

	private:
		HashTable<K, K,SetKofT,hash> _ht;
	};
}

Crink1
关注
data structure.zip_/资料_C/C++__源码/资料_C/C++_
08-09
C++标准库中的`<unordered_set>`和`<unordered_map>`提供了哈希表功能。 9. **堆**：堆是一种特殊的树形数据结构，满足堆属性（最大堆或最小堆）。C++中的`<heap>`库提供了堆操作。 10. **排序和查找算法**：如...
C++ unordered_map
m0_67393619的博客
04-29 7555
unordered_map的定义 template < class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, class Alloc = allocator< pair<const Key,T> >> class unordered_map; 模版参数说明： Key 主键的类型。 在类模板内部，使用其别名为 key_type 的成员类型。 T 被映射的值的
C++:关联式容器：unordered_map
qq_59535638的博客
06-08 5233
unordered_ map 的特性，常用接口的使用
C++ “unordered_map”详解
qq_51753728的博客
08-23 232
是 C++ 标准库中的一种关联容器，提供了哈希表功能，用于存储键值对。与std::map不同，使用哈希表实现，因此元素的存储顺序是无序的，但查找、插入和删除的时间复杂度在平均情况下是常数时间O(1)。下面是一个关于如何使用的具体例子，包括插入元素、访问元素、遍历容器等操作。示例：统计字符串中每个字符出现的次数这里定义了一个 unordered_map，用于存储字符（char 类型）和它们的出现次数（int 类型）。遍历字符串text中的每个字符。对于每个字符c，如果它不是空格，则将的值加 1。
C++语法—— STL:unordered_map
观则明的博客
10-23 6632
C++语法—— STL:unordered_map
data-structure.rar_Linux/Unix编程_C/C++_
08-11
C++标准库中的`<unordered_map>`和`<unordered_set>`是哈希表的实现。 在Linux/Unix环境中，C/C++程序员需要掌握如何利用系统调用来创建、管理这些数据结构。例如，使用`malloc`和`free`进行动态内存分配，`fork`和...
hashtable.zip_数值算法/人工智能_C/C++_
08-11
在C++中，标准库提供了`std::unordered_map`和`std::unordered_set`容器，它们都是基于哈希表实现的。`unordered_map`用于存储键值对，`unordered_set`则用于存储唯一元素。这些容器提供了近似于常数时间的插入、...
2272228-2260298.rar_数据结构_C/C++_
08-11
C++标准库中的`std::unordered_map`和`std::unordered_set`提供了哈希表功能。 在C/C++中实现这些数据结构，需要深入理解指针、动态内存分配以及内存管理。同时，为了保证代码的健壮性，还需要关注异常处理和内存...
为什么你的代码不够快？全面掌控 unordered-set 和 unordered-map 的哈希性能飙升魔法
最新发布
09-28
本文深入探讨了 C++ 标准库中的两大无序容器——unordered_set 和 unordered_map，从底层实现、核心操作、性能优化、实际应用等多个方面进行了全面分析。首先，文章介绍了这两种容器的基本概念，说明了它们基于哈希...
C++中的unordered_map常见用法详解
热门推荐
学习永无止境
01-25 1万+
文章目录 1. std::unordered_map 的定义与特性2. 构造 std::unordered_map3. 赋值操作4. 迭代器操作4.1 指向整个容器中的元素4.2 指向某个桶中的元素 5. 容量操作6. 访问操作7. 插入操作8. 删除操作9. 查找操作10. 桶操作 1. std::unordered_map 的定义与特性 所在头文件：<unordered_map> std::unorederd_map类模板： template < class K.
C++中的unordered_map用法详解
leduoduodeai的博客
10-25 7097
map： map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。unordered_map存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成。
C++——unordered_map浅析
Yawn
05-28 3126
1. 简介 从 C++ 11 开始，hash_map 实现已被添加到标准库中，但为了防止与已有的代码存在冲突，决定使用替代名称 unordered_map。这个名字其实更具描述性，因为说明了该类元素的无序性。 unordered_map记录元素的hash值，根据hash值判断元素是否相同 map相当于java中的TreeMap，unordered_map相当于HashMap 查找、插入效率：unordered_map的效率都优于hash_map，更优于map 空间复杂度：hash_map最低，unorde
C++:map和 unordered_map
weixin_43991826的博客
04-08 6227
https://blog.csdn.net/BillCYJ/article/details/78985895?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
【C++】unordered_map 的使用
xiaoyu_wu的博客
11-23 1万+
转载自：【C++】undered_map的用法总结(1) - 我得去图书馆了 - 博客园 1.介绍 unordered_map是一个关联容器，内部采用的是hash表结构，拥有快速检索的功能。 1.1 特性 关联性：通过key去检索value，而不是通过绝对地址（和顺序容器不同） 无序性：使用hash表存储，内部无序 Map : 每个值对应一个键值 键唯一性：不存在两个元素的键一样 动态内存管理：使用内存管理模型来动态管理所需要的内存空间 1.2 Hashtable和bucket 由于uno
C++中申请哈希表的函数：unordered_map讲解
FightingCSH的博客
11-17 2709
在C++中，存在一种简单申请哈希表的函数：unordered_map<element type> name {{},{}} 一.对该函数的简要介绍： 1、unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的value（hashmap<key> == value） 2、unordered_map中，键值通常用于唯一的标识元素，而映射值是一个对象，其内容与此键关联，键和映射的类型可以不同 3、在...
C++ Unordered Map
weixin_43638873的博客
05-28 1117
建议使用at( )而不是[ ]，如果传入的键不存在，at( )就会抛出异常，而[ ]会给这个键配一个脏数据。C++的STL中的unordered_map是一种无序关联容器，提供了一种无序map或字典数据结构的功能。同时unordered map是通过散列表实现的，而常规的map是通过二叉搜索树实现的。4.将一个unordered map中的内容复制到另一个新的unordered map中。(1) find( ) —— 如果键存在，返回元素迭代器，否则返回end( )迭代器。
c++哈希表unordered_set unordered_map
10-12
C++中的哈希表unordered_set和unordered_map是什么？ unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值