STL—map

---

一、什么是map

map是映射，我们在定义数组的时候int a[100];其实是一个int --> int的映射，比如a[3] = 5的含义就是把3映射到5，一个double类型的数组就是一个int --> double的映射，这里我们就能知道我们数组的一个弊端，就是只能实现int --> typename的映射，如果我们要表示一个字典的话，想要实现 字符串到页码的映射的时候显然就不好操作，这里，我们就可以用到map，map的作用就是可以把任何基本类型（包括STL），map还可以处理这么一种特殊情况：判断一些数字是否出现过，我们通常会开一个bool数组去判断，但是有一个问题就是当这个数字十分大的时候比如1e100的数量级的时候，这个数组就不能开，这个时候就可以用到map，我们可以把很大的数字当成字符串，从而建立string --> int的映射

我们在使用map之前，需要添加头文件#include <map>

---

二、map的操作

1.map的定义

map<typename1, typename2> m;

我们需要在<>中添加两种数据类型，表达的是建立一个typename1 --> typename2的映射

如果是字符串到整型的映射，必须使用string不能使用char数组

map<string, int> m;

当然，我们也可以和其他的STL容器混合起来一起使用

map<set<int>, int> m;

2.map内元素的访问

（1）通过下标访问

和访问数组是一个道理，比如对于一个map<char, int> m;，我们可以直接通过m['a']去访问'a'所对应的整数，同样，它在被赋予新值的时候会被覆盖

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 2;
    m['c'] = 3;
    
    cout << m['c'];
    
    return 0;
}

输出结果为：3

（2）通过迭代器访问

定义一个map迭代器

map<typename1, typename2>::iterator it;

typename1，typename2就是我们在定义map的时候的类型，我们把typename1称为键

map通过it -> first，it -> second去分别访问typename1，typename2

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
     
    for (map<char, int>::iterator it = m.begin(); it != m.end(); it ++ )
        cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

当然我们可以用auto去缩写

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
        
    for (auto it = m.begin(); it != m.end(); it ++ )
        cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

输出结果为：
a 1
b 2
c 3
我们发现，map会以typename从小到大进行自动排序

3.map中的函数

（1）find()

m.find(key);返回值为key的映射的迭代器，时间复杂度是O(logN)，N为map中映射的个数

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    map<char, int>::iterator it = m.find('b');
    cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

输出结果为：b 2

（2）erase()

删除单个元素

m.erase(it);，it为需要删除元素的迭代器，时间复杂度为O(1)

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    map<char, int>::iterator it = m.find('b');
    m.erase(it);              //删除 b 2
    
    for (auto it = m.begin(); it != m.end(); it ++ )
        cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

输出结果为：
a 1
c 3

m.erase(key);，key为欲删除的映射的键，时间复杂度为O(logN)，N为map内元素的个数

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    m.erase(m.find('b'));               //删除 b 2
    
    for (auto it = m.begin(); it != m.end(); it ++ )
        cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

删除一个区间内的所有元素

m.erase(first, last);，其中first是需要删除区间的起始迭代器，last为需要删除的区间的末尾迭代器的下一个地址，即删除左闭右开区间[first, last)，时间复杂度为O(last - first)

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    m.erase(m.find('b'), m.end());
    
    for (auto it = m.begin(); it != m.end(); it ++ )
        cout << it -> first << ' ' << it -> second << endl;
    
    return 0;
}

输出结果为：a 1

（4）size()

m.size()用来获得map中映射的对数，时间复杂度为O(1)

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    cout << m.size();
    
    return 0;
}

输出结果为：3

（4）clear()

m.clear();用来清空map中的所有元素，时间复杂度为O(N)，N为map中元素的个数

#include <iostream>
#include <map>

using namespace std;

int main()
{
    map<char, int> m;
    
    m['c'] = 3;
    m['a'] = 1;
    m['b'] = 2;
    
    m.clear();
    cout << m.size();
    
    return 0;
}

输出结果为：0