map、unorder_map、multimap

一.map

map是STL的一个关联容器，它提供一对一的hash。

第一个可以称为关键字(key)，每个关键字只能在map中出现一次；
第二个可能称为该关键字的值(value)；

map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的，后边我们会见识到有序的好处。比如一个班级中，每个学生的学号跟他的姓名就存在著一对一映射的关系。

map的构造函数:

1.插入元素

// 定义一个map对象
map<int, string> mapStudent; 

// 第一种 用insert函數插入pair
mapStudent.insert(pair<int, string>(000, "student_zero"));
 
// 第二种 用insert函数插入value_type数据
mapStudent.insert(map<int, string>::value_type(001, "student_one"));
 
// 第三种 用"array"方式插入
mapStudent[123] = "student_first";
mapStudent[456] = "student_second";

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是不能在插入数据的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值.

2.查找

当所查找的关键key出现时，它返回数据所在对象的位置，如果沒有，返回iter与end函数的值相同。

// find 返回迭代器指向当前查找元素的位置否则返回map::end()位置
iter = mapStudent.find("123");
 
if(iter != mapStudent.end())
       cout<<"Find, the value is"<<iter->second<<endl;
else
   cout<<"Do not Find"<<endl;

3.刪除与清空元素

//迭代器刪除
iter = mapStudent.find("123");
mapStudent.erase(iter);
 
//用关键字刪除
int n = mapStudent.erase("123"); //如果刪除了會返回1，否則返回0
 
//用迭代器范围刪除 : 把整个map清空
mapStudent.erase(mapStudent.begin(), mapStudent.end());
//等同于mapStudent.clear()

4.map的基本操作函数

C++ maps是一种关联式容器，包含“关键字/值”对
begin() 返回指向map头部的迭代器
clear(） 删除所有元素
count() 返回指定元素出现的次数
empty() 如果map为空则返回true
end() 返回指向map末尾的迭代器
equal_range() 返回特殊条目的迭代器对
erase() 删除一个元素
find() 查找一个元素
get_allocator() 返回map的配置器
insert() 插入元素
key_comp() 返回比较元素key的函数
lower_bound() 返回键值>=给定元素的第一个位置
max_size() 返回可以容纳的最大元素个数
rbegin() 返回一个指向map尾部的逆向迭代器
rend() 返回一个指向map头部的逆向迭代器
size() 返回map中元素的个数
swap() 交换两个map
upper_bound() 返回键值>给定元素的第一个位置
value_comp() 返回比较元素value的函数

5.map优点

有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
红黑树，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高
缺点： 空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点、孩子节点和红/黑性质，使得每一个节点都占用大量的空间
适用处：对于那些有顺序要求的问题，用map会更高效一些

二.unordered_map

关联性： std::unorederd_map 是一个关联容器，其中的元素根据键来引用，而不是根据索引来引用。
无序性： 在内部，std::unordered_map中的元素不会根据其键值或映射值按任何特定顺序排序，而是根据其哈希值组织到桶中，以允许通过键值直接快速访问各个元素（常量的平均时间复杂度）。
唯一性： std::unorederd_map中的元素的键是唯一的。

1.迭代器操作

指向整个容器中的元素
begin() 返回一个迭代器，指向第一个元素
end() 返回一个迭代器，指向尾后元素
cbegin() 返回一个常量迭代器，指向第一个元素
cend() 返回一个常量迭代器，指向尾后元素

2.容量操作

empty() unordered_map 是否为空
size() 获取unordered_map 中元素的数量

访问操作：
mapped_type& operator[] (key_type&& k); 如果 k 匹配容器中某个元素的键，则该函数返回该映射值的引用。如果 k 与容器中任何元素的键都不匹配，则该函数将使用该键插入一个新元素，并返回该映射值的引用。
const mapped_type& at (const key_type& k) const; 如果 k 匹配容器中某个元素的键，则该函数返回该映射值的引用。如果 k 与容器中任何元素的键都不匹配，则该函数将抛出 out_of_range 异常

3.插入操作

pair<iterator,bool> insert (const value_type& val); 类型P应当可以转换为 value_type类型 返回一个pair，其中第一个值为一个迭代器，指向新插入的元素或其键等于待插入元素的键的元素（原先就已存在的元素）；第二个值是一个bool值，当插入一个新元素时，该值设为true，当该键已存在时，该值设为false。

4.删除操作

iterator erase (const_iterator position); 根据元素位置 返回一个迭代器，指向被删除元素的后一个元素
size_type erase (const key_type& k); 根据元素的键 返回被删除元素的数目，此处为1
由一对范围迭代器指定删除的范围
iterator erase (const_iterator first, const_iterator last); 返回一个迭代器，指向最后一个被删除元素的后一个元素
void clear() noexcept; 删除所有元素

5.查找

const_iterator find (const key_type& k) const; 在容器中搜索键值等于 k 的元素，如果找到，则返回一个指向该元素的迭代器，否则返回一个指向unordered_map :: end的迭代器。

size_type bucket_count() const noexcept; 获取容器中桶的数目
size_type bucket_size ( size_type n ) const; 获取第 n 个桶中元素的数量
size_type bucket ( const key_type& k ) const; 获取键为 k 的元素所在桶的序号

bucket_count()：返回unordered_map容器中的桶数。 桶是容器内部哈希表中的一个槽，根据其键的哈希值将元素分配给该槽。 桶的数量直接影响容器哈希表的负载因子（从而影响碰撞的概率）。 容器自动增加桶的数量，以保持负载因子低于特定的阈值(其max_load_factor)，每次需要增加桶的数量时都会导致重新散列…
优点： 因为内部实现了哈希表，因此其查找速度非常的快
缺点： 哈希表的建立比较耗费时间
适用处： 对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

三.map与unordered_map区别

unordered_map 与 map之间差异比较（Linux平台下）
map底层为红黑树查找大致为logN的时间复杂度；unordered_map底层是闭散列的哈希桶，查找为O(1)，性能更优。
调用insert操作，map相较于unordered_map操作慢，大致有2到3倍差异；但是map插入更加稳定
unordered_map的erase操作会缩容，导致元素重新映射，降低性能。
unordered_map要求传入的数据能够进行大小比较。
multimap与map不同的地方在于multimap可以插入键值相同的元素
equal_range可以返回指向相同键值的起始终止iterator

四.multimap：

multimap多重映照容器:容器的数据结构采用红黑树进行管理
multimap的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
multimap特性以及用法与map完全相同，唯一的差别在于:
允许重复键值的元素插入容器(使用了RB-Tree的insert_equal函数)
因此:键值key与元素value的映照关系是多对多的关系
没有定义[]操作运算
使用multimap必须使用宏语句#include

创建multimap对象:

1.multimap<char,int,greater > a; //元素键值类型为char,映照数据类型为int,键值的比较函数对象为greater，降序
2.multimap(const key_compare& comp) //指定一个比较函数对象comp来创建map对象
3.multimap(const multisetr&); //multimap<int,char*> b(a); //此时使用默认的键值比较函less该容器是按键的升序方式排列元素。未指定函数对象，默认采用less函数对象。

class Solution {
public:
    string frequencySort(string s) {
        map<char, int> mp;
        //multimap<int, char,greater<int>> i2ch;
        multimap<int, char> i2ch;
        for(char ch: s)
            mp[ch]++;
        for(auto p=mp.begin(); p!=mp.end(); p++)
            i2ch.insert(make_pair(p->second, p->first));
        int idx = s.size()-1;
        int i=0;
        for(auto p=i2ch.begin(); p!=i2ch.end();p++){
            int freq = p->first;
            char ch = p->second;
            cout<<i<<ch<<endl;
            i++;
            while(freq-- > 0)
                s[idx--] = ch;
        }
        return s;
    }
};

stdout>>
0r
1t
2e
3f
4z

find:
搜索一个元素的容器，其中一个键相当于k，如果找到了，则返回一个迭代器给它，否则它迭代器返回到multimap：end。
请注意，此函数将迭代器返回给单个元素（可能有多个元素的等效键）。 若要获得整个等效元素范围，请参见多映射：equal_range。

td::multimap::equal_range

pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator> equal_range (const key_type& k);

返回一个范围的界限，其中包括容器中所有具有相当于k的键的元素。如果没有找到匹配，则返回的范围的长度为零，两个迭代器都指向第一个元素，该元素根据容器的内部比较对象(key_comp)考虑在k之后执行键。 如果容器的比较对象反射地返回false，则两个键被认为是等价的（即，无论键作为参数传递的顺序）。

// multimap::equal_range
#include <iostream>
#include <map>

int main ()
{
  std::multimap<char,int> mymm;

  mymm.insert(std::pair<char,int>('a',10));
  mymm.insert(std::pair<char,int>('b',20));
  mymm.insert(std::pair<char,int>('b',30));
  mymm.insert(std::pair<char,int>('b',40));
  mymm.insert(std::pair<char,int>('c',50));
  mymm.insert(std::pair<char,int>('c',60));
  mymm.insert(std::pair<char,int>('d',60));

  std::cout << "mymm contains:\n";
  for (char ch='a'; ch<='d'; ch++)
  {
    std::pair <std::multimap<char,int>::iterator, std::multimap<char,int>::iterator> ret;
    ret = mymm.equal_range(ch);
    std::cout << ch << " =>";
    for (std::multimap<char,int>::iterator it=ret.first; it!=ret.second; ++it)
      std::cout << ' ' << it->second;
    std::cout << '\n';
  }

  return 0;
}
out>>
mymm contains:
a => 10
b => 20 30 40
c => 50 60
d => 60