map/unordered_map

1. map

   1）map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对。它提供基于key的快速检索能力。

   2）map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。

   3）map的具体实现采用红黑树变体的平衡二叉树的数据结构。在插入操作和删除操作上比vector快。

   4）map可以直接存取key所对应的value，支持[]操作符，如map[key]=value。

   map对象的构造

map<T1,T2> mapX;

   map的插入与迭代器

map<int, string> mapStu;
mapStu.insert(pair<int,string>(3,"Jack"));            // return pair<map<int, string>::iterator,bool>
mapStu.inset(make_pair(0, "John"));                   // return pair<map<int, string>::iterator,bool>
mapStu.insert(map<int,string>::value_type(1,"小李")); // return pair<map<int, string>::iterator,bool>
void insert(InputIterator first, InputIterator last); // 插入一个范围

mapStu[3] = "小明";          // 这种方法虽然非常直观，但存在一个性能的问题。插入3时，先在mapStu中查找主键为3的项，
                             // 若没发现，则将一个键为3，值为初始化值的对组插入到mapStu中，然后再将值修改成"小明"。
                             // 若发现已存在3这个键，则修改这个键对应的value
string strName = mapStu[2];  // 只有当mapStu存在2这个键时才是正确的取操作，否则会自动插入一个实例，键为2，值为初始化值。
 
map.begin();   // 返回容器中第一个数据的迭代器。
map.end();     // 返回容器中最后一个数据之后的迭代器。
map.rbegin();  // 返回容器中倒数第一个元素的迭代器。
map.rend();    // 返回容器中倒数最后一个元素的后面的迭代器。
 
// 迭代器遍历
for (map<int,string>::iterator it=mapA.begin(); it!=mapA.end(); ++it)
{
    pair<int, string> pr = *it;
    int iKey = pr.first;
    string sValue = pr.second;
}

   map选择key排序方式

map<T1,T2,less<T1> >  mapA;    // 该容器是按键的升序方式排列元素。未指定函数对象，默认采用less<T1>函数对象。
map<T1,T2,greater<T1>> mapB;   // 该容器是按键的降序方式排列元素。
// less<T1> 与 greater<T1> 可以替换成其它的函数对象functor。

   map对象的拷贝构造与赋值

map(const map &mp);             // 拷贝构造函数
map& operator=(const map &mp);  // 重载等号操作符
map.swap(mp);                   // 交换两个容器集合

   map的大小

map.size();   // 返回容器中元素的数目
map.empty();  // 判断容器是否为空

   map的删除

map.clear();                                                  // 删除所有元素
iterator  erase(const_iterator position);                     // 删除pos迭代器所指的元素，返回下一个元素的迭代器
size_type erase(const key_type& k);                           // 删除容器中key为k的pair
iterator  erase(const_iterator first, const_iterator last);   // 除区间[beg,end)的所有元素，返回下一个元素的迭代器

   map的查找

iterator find(const key_type& k);          // 查找键key是否存在，若存在，返回该键的元素的迭代器;若不存在，返回map.end();
size_type count(const key_type& k) const;  // 返回容器中key为 k 的对组个数。对map来说，要么是0，要么是1
iterator lower_bound(const key_type& k);   // 返回第一个 key>=k 元素的迭代器
iterator upper_bound(const key_type& k);   // 返回第一个 key>k 元素的迭代器

2. unordered_map

   它是一个关联容器，内部采用的是hash表结构，拥有快速检索的功能。每个key会通过一些特定的哈希运算映射到一个特定的位置，我们知道，

   hashtable是可能存在冲突的（多个key通过计算映射到同一个位置），在同一个位置的元素会按顺序链在后面。所以把这个位置称为一个bucket是

   十分形象的（像桶子一样，可以装多个元素）。

   

   所以 unordered_map 内部其实是由很多哈希桶组成的，每个哈希桶中可能没有元素，也可能有多个元素。每当桶不够用时，桶数会以

   大致 bucket[n] = 2 * bucket[n-1] + 奇数 （1， 3， 5， 9 ...）来增长。与 vector 成倍增长是不同的。

   这里我们将map和unordered_map做一个对比：

   1）map在缺省下，按照递增的排序顺序，unordered_map不排序。

   2）Map中桶的元素初始化是链表保存的，其查找性能是O(n)。当链表长度很小的时候，即使遍历，速度也非常快，但是当链表长度不断

      变长，肯定会对查询性能有一定的影响，而树结构能将查找性能提升到O(log(n))，这时map内部存储结构由链表转成树。

      unordered_map内部实现是哈希表(数组)，由链地址法解决冲突。

   3）map搜索时间复杂度为log(n)。unordered_map搜索时间复杂度，O(1)为平均时间，最坏情况下的时间复杂度为O(n)。

   4）map空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点，孩子节点以及红/黑性质，

      使得每一个节点都占用大量的空间。unordered_map建立哈希表比较耗费时间，但查找速度更快(受到冲突的影响)。

   unordered_map对象的构造

unordered_map<T1,T2> mapX;

   unordered_map的插入与迭代器

std::unordered_map<std::string, double> map1, map2 = { {"milk",2.0},{"flour",1.5} };
std::pair<std::string, double> myshopping("baking powder",0.3);

map1.insert(myshopping);                                      // copy insertion
map1.insert(std::make_pair<std::string, double>("eggs",6.0)); // move insertion
map1.insert(map2.begin(), map2.end());                        // range insertion
map1.insert({ {"sugar",0.8}, {"salt",0.1} });                 // initializer list insertion

umap.begin();   // 返回容器中第一个数据的迭代器。
umap.end();     // 返回容器中最后一个数据之后的迭代器。

for (auto& x: map1) {
    std::cout << x.first << ": " << x.second << std::endl;
}

   自定义哈希函数

   使用自定义哈希函数可以有效避免构造数据产生的大量哈希冲突。要想使用自定义哈希函数，需要定义一个结构体，并在结构体中重载()运算符。

// 通过 unordered_map<int, int, my_hash> my_map; 的定义方式将自定义的哈希函数传入容器了。
struct my_hash 
{
    static uint64_t splitmix64(uint64_t x) 
    {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const 
    {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

   unordered_map对象的拷贝构造与赋值

unordered_map(const unordered_map& ump);             // 拷贝构造函数
unordered_map(unordered_map&& ump);                  // 移动构造函数
unordered_map& operator=(const unordered_map& ump);  // 重载赋值运算符
unordered_map& operator=(unordered_map&& ump);       // 移动赋值
void swap(unordered_map& ump);                       // 交换两个容器集合

   unordered_map的大小

umap.size();          // 返回容器中元素的数目
umap.empty();         // 判断容器是否为空
umap.bucket_count();  // 返回容器中桶的数目
umap.bucket_size(n);  // 返回第n个桶中元素个数 

   unordered_map的删除

umap.clear();                                                 // 删除所有元素
iterator  erase(const_iterator position);                     // 删除pos迭代器所指的元素，返回下一个元素的迭代器
size_type erase(const key_type& k);                           // 删除容器中key为k的pair
iterator  erase(const_iterator first, const_iterator last);   // 除区间[beg,end)的所有元素，返回下一个元素的迭代器

   unordered_map的查找

iterator find(const key_type& k);          // 查找键key是否存在，若存在，返回该键的元素的迭代器;若不存在，返回umap.end();
size_type count(const key_type& k) const;  // 返回容器中key为 k 的对组个数。对umap来说，要么是0，要么是1