STL总结之unordered_map/unordered_multimap

介绍

unordered_map 是一个封装哈希表的无序容器。容器中每个元素都是 key/value，每个 key 仅可出现一次。
unordered_multimap 是一个封装哈希表的无序容器。容器中每个元素都是 key/value，每个 key 可重复出现。
unordered_map 和 unordered_multimap 均定义于头文件 <unordered_map> 中，各自声明如下：

template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_map;

template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_multimap;

到这里可能有一个问题：map 和 unordered_map / multimap 和 unordered_multimap 应该使用哪一种 (关联式容器和无序容器应该使用哪一种)？
考虑一个容器好坏，有一个标准是查看插入元素和查询元素的复杂度。
对于顺序容器，往往是插入复杂度高，查询复杂度低；又或者插入复杂度低，查询复杂度高，两者不能兼顾。
对于关联式容器，通过基于树结构，可以实现插入和查询都具有不太高的复杂度，而且其中元素是有序的。
对于无序容器，通过线性+链表，可以使得插入和查询复杂度更低，但是元素顺序会被打乱。

从上面的比较可以看出，在选择关联式容器和无序容器时，如果题目不涉及有序问题，应优先使用无序容器。

unordered_map 和 unordered_multimap 都是基于哈希表实现的，而且冲突策略采用的是链地址法。示意图如下：

如图所示，容器每一行都是一条链，在unordered_map 和 unordered_multimap 中称其为一个桶，所有冲突的元素放在同一个桶中。
我们知道哈希表实现中需要避免冲突，因为冲突过大会导致其退化为 线性表；同时如果最初分配空间过大，会造成极大的浪费。因此unordered_map 和 unordered_multimap 容器中桶的个数会根据元素个数动态变化。

初始化

unordered_map 和 unordered_multimap 基于哈希表实现，因此当创建一个容器时，需要指定 hash 函数 和 冲突查询时的 equal 函数。
对于基本数据类型，标准库提供了一个简单的 hash 和 equal 函数。但是对于复杂的数据类型，则需要我们自己指定。
指定 hash 和 equal 函数的方法如下：

• 以 类型参数 定义，需要定义一个 函数对象。

  struct MyHash { 
   	// 这里假定 T = pair<int,int>
   	// 函数参数需要 const，函数本身也必须是 const
    	size_t operator()(const T& a) const
    	{
    		// hash<int>()(num) 是标准库定义的用于获取基本数据类型的 hash 函数
    		return hash<int>()(a.first) ^ hash<int>()(a.second);
    	}
    };
  
    struct MyEqual {
      // 这里假定 T = pair<int,int>
      // 函数参数需要 const，函数本身也必须是 const
    	bool operator()(const T& a,const T& b) const
    	{
    	   // equal_to<int>()(num) 是标准库定义的用于判断基本数据类型是否相等的函数
    		return (equal_to<int>()(a.first,b.first) && (equal_to<int>()(a.second,b.second)));
    	}
    };
    
    unordered_map<pair<int,int>,pair<int,int>,MyHash,MyEqual> ump;
  

以下构造函数都不涉及定义 hash 和 equal 函数，均采用默认的 hash 和 equal 函数。

• unordered_map<T,T> ump; / unordered_multimap<T,T> ummp;
  创建一个空的 unordered_map / unordered_multimap 容器。

  unordered_map<int,string> ump;
  

• unordered_map<T,T> ump(bucket_count); / unordered_multimap<T,T> ummp(bucket_count);
  创建一个空的 unordered_map / unordered_multimap 容器，且该容器至少含有 bucket_count个桶。

  unordered_map<int,string> ump(8);
  cout << us.bucket_count() << endl; // 输出结果为 11
  

• unordered_map<T,T> ump({num1,num2,……}) / unordered_multimap<T,T> ummp({num1,num2,……})
  创建一个以初值列元素为初值的 unordered_map / unordered_multimap 容器。

  unordered_map<int,string> ump({{0,"zero"},{1,"one"});
  

• unordered_map<T,T> ump ={num1,num2,……}) / unordered_multimap<T,T> ummp({num1,num2,……})
  创建一个以初值列元素为初值的 unordered_map / unordered_multimap 容器。

  unordered_map<int,string> ump({{0,"zero"},{1,"one"});
  

修改

unordered_map / unordered_multimap容器禁止修改键值。
unordered_map / unordered_multimap容器可以修改键值对应的 value值。因此 unordered_map / unordered_multimap容器提供了一些方法进行访问：

• at(key)
  返回unordered_map容器中键值 key 对应元素的 value的引用。如果不存在，则返回 std::out_of_range。
• operator[key]
  返回unordered_map容器中键值 key 对应元素的 value的引用。如果不存在，则插入该键值对。
• 迭代器
  这种方法需要遍历 unordered_map / unordered_multimap 容器。
  迭代器指向的是 unordered_map / unordered_multimap 容器中的元素，欲获取其中的键和值，需如下使用：

  unordered_map<int,string>::iterator ite = ump.begin();
  cout << "键："  << (*ite).first << endl;
  cout << "值：" << (*ite).second << endl;
  

查询

• empty()
  判断 unordered_map / unordered_multimap 容器是否为空。
• size()
  返回 unordered_map / unordered_multimap 容器中的元素个数。
• max_size()
  返回 unordered_map / unordered_multimap 容器大小的理论极限值，即当前内存情况下，允许创建 unordered_map / unordered_multimap 容器中元素个数的最大可能值。
• count(key)
  返回 unordered_map / unordered_multimap 容器中键值为 key 的元素个数。
• find(key)
  判断 unordered_map / unordered_multimap 容器中是否存在键值为 key 的元素，如果存在，则返回第一个符合条件的迭代器，否则返回 end()。

比较

仅提供两个重载运算符 == 和 != 用于 unordered_map / unordered_multimap 容器的比较。

增加

• insert(pair<T.T>())
  向 unordered_map / unordered_multimap 容器中插入一个元素。
  对于 unordered_map 容器，返回值类型为 pair<unordered_map<T,T>::iterator,bool>。unordered_map<T,T>::iterator 指向插入元素位置的迭代器，bool 表示插入是否成功。
  对于 unordered_multimap 容器，返回指向插入位置的迭代器。

  unordered_map<int,string> ump = {{0,"zero"},{1,"one"}};
  ump.insert(pair<int,string>(2,"two"));
  

• insert(begin_iterator,end_iterator);
  向 unordered_map / unordered_multimap 容器中插入迭代器区间 [begin_iterator,end_iterator) 内的所有元素。
  对于 unordered_map 容器而言，可能存在元素插入失败。

  unordered_map<int,string> ump1 = {{0,"zero"},{1,"one"}};
  unordered_map<int,string> ump;
  ump.insert(ump1.begin(),++ump1.begin()); 
  // ump 容器迭代元素依次为：{1,"one"}
  

删除

• clear()
  清空 unordered_map / unordered_multimap 容器。
• erase(pos_iterator)
  移除 unordered_map / unordered_multimap 容器指定位置 pos_iterator 处元素。

  unordered_map<int,string> ump = {{0,"zero"},{1,"one"}};
  ump.erase(ump.begin()); 
  // ump 容器迭代元素依次为：{0,"zero"},
  // 仅仅通过代码，是无法得知到底移除的是哪一个元素，因为容器内部元素是无序的。
  

• erase(begin_iterator,end_iterator)
  移除 unordered_map / unordered_multimap 容器指定迭代器区间 [begin_iterator,end_iterator) 内的所有元素。

  unordered_map<int,string> ump = {{0,"zero"},{1,"one"},{2,"two"},{3,"three"}};
  ump.erase(ump.begin(),++(++ump.begin()));
  // ump 容器迭代元素依次为：{1,"one"},{2,"two"}
  

• erase(key)
  移除unordered_map / unordered_multimap 容器内键值等于 key 的所有元素，返回移除元素数目。

其他操作

• equal_range(key)
  返回 unordered_map / unordered_multimap 容器中键值等于 key 的迭代器区间。
  其返回值为 pair<iterator,iterator>，iterator指向第一个元素值等于 key 的迭代器位置，第二个iterator 指向最后一个元素值等于 key 迭代器位置的下一个位置。
• bucket_count()
  返回 unordered_map / unordered_multimap 容器中桶的个数。
• bucket_size(index)
  返回 unordered_map / unordered_multismap 容器特定桶中元素数目。