STL整理之map

转载请注明出处，部分内容引自李煜东《算法竞赛进阶指南》

---

前置知识： $C++、C$语言入门

---

$Map$是什么

Map是从键（$key$）到值（$value$）的映射，其内部实现是一棵以$key$为关键码的红黑树

$Map$的相关操作

头文件

#include<map>

声明：

像这样：

map<key的类型，value的类型>名称；

比如：

map<long long,bool>mp;
map<string,int>mp;
map<pair<int,int>,vector<int>>mp;

就像其他需要排序的数据类型一样，$key$为一个结构体的$map$，需要重载小于号

struct pos{
    int x,y,s;
    string move[100];
};
map<pos,int>mp;
bool operator <(const pos &ai,const pos &bi)
{
    return (ai.x==bi.x)?ai.y>bi.y:ai.x>bi.x;
}

[]运算符

$map$重载了[]运算符，$map[key]$返回$key$到$value$的引用，时间复杂度$O(log n)$

[]操作符是$map$最吸引人的地方。我们可以很方便地通过$map[key]$来得到$key$对应的$value$，还可以对$map[key]$进行赋值操作，改变$key$对应的$value$。

若查找的$key$不存在，则执行$map[key]$后，$map$会自动新建一个二元组$(key,zero)$，并返回$zero$的引用。

eg.
map<string,int>mp;
for(int i=1;i<=n;i++)
{
    string s;
    int num;
    cin>>s>>num;
    mp[s]=num;
}
for(int i=1;i<=m;i++)
{
    string s;
    cin>>s;
    cout<<mp[s]<<endl;
}

$map.size()$

统计$map$中元素个数，函数返回一个整形变量，表示$map$中元素个数，时间复杂度$O(1)$

用法：名称.size();
eg.
int num=mp.size();

$map.empty()$

检查$map$是否为空，返回一个$bool$型变量，1表示$map$为空，否则为非空，时间复杂度$O(1)$

用法：名称.empty();
eg.
if(mp.empty())
    cout<<"Mymap is Empty."<<endl;

$map.clear()$

清空$map$，无返回值

用法：名称.clear();
eg.
mp.clear();

$map.count(x)$

返回$map$中$key$为$x$的元素个数，时间复杂度为$O(log n)$

用法：名称.count(x)
eg.
if(!mp.count(x))
    mp[x]=1;

迭代器

双向访问迭代器，不支持随机访问，支持星号解除引用，仅支持“++”，“–”这两个算术操作

引用和操作：

map<类型,类型>::iterator it;
eg.
map<int,int>::iterator it=mp.begin();
it++;
it--;

若把$it++$，则$it$将会指向“下一个”元素。这里的下一个是指在$key$从小到大排序的结果中，排在$it$下一名的元素。同理，若把$it--$，则$it$会指向排在上一个的元素

“++”，“–”操作的复杂度均为$O(log n)$

对$map$的迭代器解除引用后，将得到一个二元组$pair<...,...>$

遍历$map$及访问其中的元素

for(map<int,int>::iterator it=mp.begin();it!=mp.end();it++)
    if(it->second==ans)     //访问二元组中第二个，即value
        cout<<it->first<<endl;      //访问key

$map.find(x)$

在$map$中查找$key$为$x$的二元组，并返回指向该二元组的迭代器，若不存在，返回$map.end()$，时间复杂度为$O(log n)$

用法：名称.find(x);
eg.
if(mp.find(s)!=mp.end())
    cout<<"Have Found!"<<endl;

$map.insert(pair<...,...>)$

在$map$中插入，参数是$pair<key.type,value.type>$，返回插入地址的迭代器和是否插入成功的$bool$并成的$pair$，时间复杂度为$O(log n)$

PS：$insert$在进行插入的时候是不允许有重复的键值的，如果新插入的键值与原有的键值重复则插入无效

用法：名称.insert(pair<key的类型,value的类型>);
eg.
mp.insert(make_pair(2,3));

$map.erase(参数)$

删除，参数可以是$pair$或者迭代器，返回下一个元素的迭代器，时间复杂度为$O(log n)$

用法：名称.erase(参数);
eg.
map<int,int>::iterator it=mp.begin();
mp.erase(it);
mp.erase(make_pair(2,3));