STL【容器】| 【11】unordered_map

一、unordered_map

无序映射是存储由key和映value组合形成的元素的关联容器，并且允许基于键快速检索单个元素素；

• 采用哈希桶的数据结构；
  • 桶是内部哈希表中的一个槽，元素根据哈希函数计算的哈希值分配给该槽；
  • 桶的数量直接影响哈希表的负载因子——碰撞的概率；
  • 增加桶的数量时都会导致重新散列；

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

1、常用成员函数

• begin()：返回第一个元素；
• end()：返回最后一个元素后面一个位置；
• rbegin()：返回容器最后一个元素；
• rend()：返回第一个元素前的一个位置；
• size()：元素个数；
• max_size()：最大元素个数；
• empty()：判断是否为空；
• emplace()：插入元素，能够自动构造对象；
• emplace_hint()：根据位置插入；
• insert()：删除指定值的元素；
• insert(pos, elem)：在pos插入elem
• insert(pos, n, elem)：pos位置插入n个元素elem；
• erase(cmp)：删除满足条件的元素；
• erase()：删除一个或几个元素；
• swap()：交换容器；
• clear()：删除双端队列容器中的所有元素；
• find()：获取元素的迭代器；
• count()：查看是否具有特定值的元素；
• equal_range()：获取相等元素的范围；
• bucket_count()：获取桶数；
• max_bucket_count()：获取最大桶数；
• bucket_size()：获取桶的大小；
• bucket()：定位元素的桶；
• load_factor()：负载因子是容器中元素个数与桶数的比值；
• max_load_factor()：获取或设置最大负载因子；
• rehash()：设置桶数；
  • 当设置的桶数大于当前桶数，则新的桶数会大于等于设置的桶数；
  • 若当前设置的桶数小于，则该函数操作可能无影响；
• reserve()：请求容量更改；
  • n应该至少包含n个元素的桶数，若设置过低则无效；
  • 若大于max_bucket_count/max_load_factor，则容器的bucket_count会增加并强制重新哈希
• hash_function()：获取哈希函数；
• key_eq()：获取键等价谓词；
• []：访问元素；
• at()：访问元素；

2、案例

#include<iostream> 
#include <unordered_map>
#include <string>
using namespace std;

unordered_map<int, string> u_map = {{1, "jj"}, {2, "pp"}, {3, "ii"}};

void test() {
	
	// ret: 3
	//cout << "size: " << u_map.size() << endl;
	
	// ret: 357913941
	//cout << "max_size: " << u_map.max_size() << endl;	
	
	// ret: find!!! pp
	//auto it = u_map.find(2);
	//if(it != u_map.end())
	//	cout << "find!!! " << it->second << endl;
	//else
	//	cout << "no find!!!" << endl;
		
	// ret: find 2"
	//if(u_map.count(2) == 0) {
	//	cout << "2 not in u_set" << endl;
	//}else 
	//	cout << "find 2" << endl;
	
	// ret: 2 pp
	//auto it = u_map.equal_range(2);
	//cout << it.first->first << " " << it.first->second << endl;

	// ret: 4
	//u_map.emplace(100, "uu");
	//cout << "size: " << u_map.size() << endl;
	
	// ret: 4
	//u_map.emplace_hint(u_map.begin(), 200, "kk");
	//cout << "size: " << u_map.size() << endl;
	
	// ret: 4
	//u_map.insert({290, "ll"});
	//cout << "size: " << u_map.size() << endl;

	// ret: 0
	//u_map.clear();
	//cout << "size: " << u_map.size() << endl;
	
	// ret: 3 ii 1 jj
	//u_map.erase(2);
	//for(auto i:u_map) {
	//	cout << i.first << " " << i.second << " ";
	//}
	
	// ret: 20 ss 19 yy
	//unordered_map<int, string> tmp = {{19, "yy"}, {20, "ss"}};
	//u_map.swap(tmp);
	//for(auto i:u_map) {
	//	cout << i.first << " " << i.second << " ";
	//}
	
	// ret: 7
	//cout << u_map.bucket_count() << endl; 
	
	// ret: 357913941
	//cout << u_map.max_bucket_count() << endl;
	
	
	/* ret: 
		0 0
		1 1
		2 1
		3 1
		4 0
		5 0
		6 0
	*/
	//for(size_t i=0; i<u_map.bucket_count(); ++i) {
	//	cout << i << " " << u_map.bucket_size(i) << endl;
	//}
	
	/* ret:
	3 in #3
	2 in #2
	1 in #1
	*/
	//for(auto i:u_map) {
	//	cout << i.first << " in #" << u_map.bucket(i.first) << endl;	
	//}
	
	/* ret: 
	 	负载因子：0.428571
		最大负载因子：1
	*/
	//cout << "负载因子：" << u_map.load_factor() << endl;
	//cout << "最大负载因子：" << u_map.max_load_factor() << endl;
	
	// ret: 11
	//u_map.rehash(8);
	//cout << u_map.bucket_count() << endl;

	// ret: 11	
	//u_map.reserve(8);
	//cout << u_map.bucket_count() << endl;	
}

int main() {
	
	test();
	return 0;
}