C++STL之map和unordered_map详解

inforx

已于 2023-07-24 10:03:05 修改

阅读量2.3k

点赞数 1

分类专栏： C++ STL 文章标签： c++ 开发语言

于 2023-07-06 22:10:07 首次发布

本文链接：https://blog.csdn.net/zhendong825/article/details/131585231

版权

C++ STL 专栏收录该内容

15 篇文章 3 订阅

订阅专栏

一、关联式容器和键值对

1.关联式容器

前面的STL的容器，如vector、list、deque等都是序列式容器，因为

（1）底层的数据结构是线性的
（2）存储的是元素本身
（3）数据和数据之间没有关联

关联式容器也是用来存储数据的，不过里面存储的是<key, value>键值对，数据检索时，效率比序列式容器高。

STL有两种关联式容器：树形结构和哈希结构。树形结构的关联式容器有4种：set、map 、multiset
、multimap，它们的底层都是平衡搜索树（红黑树）。

2.键值对pair

pair用来表示具有一一对应关系的结构，pair只含有两个元素，可以看作是只有两个元素的结构体。该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。

//头文件
#include<utility>

//1.初始化定义
pair<string,int> p("wangyaqi",1);//带初始值的
pair<string,int> p;//不带初始值的

//2.赋值
p = {"wang",18};

作为map键值对进行插入

map<string,int>mp;
mp.insert(pair<string,int>("xingmaqi",1));

访问

//定义结构体数组
pair<int,int>p[20];
for(int i = 0; i < 20; i++)
{
	//和结构体类似，first代表第一个元素，second代表第二个元素
	cout << p[i].first << " " << p[i].second;
}

二、map

1.map特点

map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:
在内部，map中的元素总是按照键值key进行比较排序的。
map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
map通常被实现为平衡二叉搜索树(红黑树)。

2.头文件和初始化

//头文件
#include<map>
//初始化定义
map<string,string> mp;
map<string,int> mp;
map<int,node> mp;//node是结构体类型

3.接口函数

代码	含义	时间复杂度
mp.find(key)	返回键为key的映射的迭代器注意：用find函数来定位数据出现位置，它返回一个迭代器。当数据存在时，返回数据所在位置的迭代器，数据不存在时，返回mp.end()	O(logN)
mp.erase(it)	删除迭代器对应的键和值	O(1)
mp.erase(key)	根据映射的键删除键和值	O(logN)
mp.erase(first,last)	删除左闭右开区间迭代器对应的键和值	O(last-first)
mp.size()	返回映射的对数	O(1)
mp.insert()	插入元素，插入时要构造键值对
mp.clear()	清空map中的所有元素	O(N)
mp.empty()	如果map为空，返回true，否则返回false
mp.begin()	返回指向map第一个元素的迭代器（地址）
mp.end()	返回指向map尾部的迭代器（最后一个元素的下一个地址）
mp.rbegin()	返回指向map最后一个元素的反向迭代器（地址）
mp.rend()	返回指向map第一个元素前面(上一个）的反向迭代器（地址）
mp.count(key)	查看元素是否存在，因为map中键是唯一的，所以存在返回1，不存在返回0
mp.lower_bound()	返回一个迭代器，指向键值>= key的第一个元素
mp.upper_bound()	返回一个迭代器，指向键值> key的第一个元素

查找元素是否存在时，可以使用
1️⃣mp.find() 2️⃣ mp.count() 3️⃣ mp[key]
但是第三种情况，如果不存在对应的key时，会自动创建一个键值对（产生一个额外的键值对空间）
所以为了不增加额外的空间负担，最好使用前两种方法

使用迭代器进行正反向遍历

用于正向遍历map

map<int,int> mp;
mp[1] = 2;
mp[2] = 3;
mp[3] = 4;
auto it = mp.begin();
while(it != mp.end())
{
	cout << it->first << " " << it->second << "\n";
	it ++;
}

//结果：
1 2
2 3
3 4

用于逆向遍历map

map<int,int> mp;
mp[1] = 2;
mp[2] = 3;
mp[3] = 4;
auto it = mp.rbegin();
while(it != mp.rend())
{
	cout << it->first << " " << it->second << "\n";
	it ++;
}

//结果：

3 4
2 3
1 2

二分查找
lower_bound() upper_bound()

map的二分查找以第一个元素（即键为准），对键进行二分查找,返回值为map迭代器类型

#include<bits/stdc++.h>
using namespace std;

int main()
{
	map<int, int> m{{1, 2}, {2, 2}, {1, 2}, {8, 2}, {6, 2}};//有序
	map<int, int>::iterator it1 = m.lower_bound(2);//返回一个迭代器，指向键值>= key的第一个元素
	cout << it1->first << "\n";//it1->first=2
	map<int, int>::iterator it2 = m.upper_bound(2);//返回一个迭代器，指向键值> 2的第一个元素
	cout << it2->first << "\n";//it2->first=6
	return 0;
}

添加元素

//先声明
map<string,string> mp;
map<int, int>mp

方式一：

mp["学习"] = "看书";
mp["玩耍"] = "打游戏";

方式二：插入元素构造键值对

mp.insert(make_pair("vegetable","蔬菜"));

方式三：插入pair

mp.insert(pair<string,string>("fruit","水果"));

方式四:直接插入花括号对

mp.insert({"fruit","水果"});

访问元素

下标访问

mp["fruit"] = "水果";
cout << mp["fruit"] << "\n";

遍历访问

方式一：迭代器访问

map<string,string>::iterator it;
for(it = mp.begin(); it != mp.end(); it++)
{
	//      键                 值 
	// it是结构体指针访问所以要用 -> 访问
	cout << it->first << " " << it->second << "\n";
	//*it是结构体变量 访问要用 . 访问
	//cout<<(*it).first<<" "<<(*it).second;
}

方式二：智能指针访问

for(auto i : mp)
cout << i.first << " " << i.second << endl;//i是结构体变量 访问要用 . 访问

方式三：对指定单个元素访问

map<char,int>::iterator it = mp.find('a');
cout << it -> first << " " <<  it->second << "\n";

方式四：c++17特性才具有

for(auto [x, y] : mp)
	cout << x << " " << y << "\n";
//x,y对应键和值

查找

使用[]查找元素时，如果元素不存在，会创建一个空的元素；如果存在，会正常索引对应的值。所以如果查询过多的不存在的元素值，容器内部会创建大量的空的键值对，后续查询创建删除效率会大大降低。
查询容器内部元素的最优方法是：先判断存在与否，再索引对应值

map<int, int> mp;
int x = 999999999;
if(mp.count(x)) // 此处判断是否存在x这个键
    cout << mp[x] << "\n";   // 只有存在才会索引对应的值，避免不存在x时多余空元素的创建

按键值降序排列

map<int, int, greater<int> >

键值为自定义结构体时需要自定义键值排序

#include<iostream>
#include<map>
using namespace std;
struct Node
{
int x;
	int y;
	int z;
Node() {}
Node(int x, int y, int z):x(x), y(y), z(z){} //赋值
};
//自定义比较规则
//注意operator是(),不是＜
struct cmp
{
bool operator() (const Node& a,const Node& b) const //从小到大
{
if (a.x == b.x) {
			if(a.y == b.y) {
				return a.z > b.z;	// 第3顺序按z降序排列
			}
			return a.y > b.y;		// 第2顺序按y降序排列
		}
		return a.x < b.x;			// 第3顺序按x升序排列

}
};

int main()
{	int a = 0;
	int maxSize = 4;
   Node node[maxSize] = {{1,5,9}, {2, 6, 10}, {2, 9, 8}, {2,9,3}};
    //注意此处一定要有Cmp，否则无法排序会报错
    map<Node,int,cmp>mp;
	for(int i = 0; i < 4; i++) {
		a = rand()%4;
		mp.insert(pair<Node,int>(node[i],a));
	}

    map<Node,int>::iterator iter;
    for(iter=mp.begin(); iter!=mp.end(); iter++)
	cout<<iter->first.x<<" "<<iter->first.y<<" "<<iter->first.z<<" "<<iter->second<<endl;
    return 0;
}

按照val值进行排序

将数据在可以使用sort的容器中排序，这里用vector举例

struct cmp
{
	bool operator()(const pair<int, int>&p1,const pair<int, int>& p2)
	{
		if(p1.first == p2.first) {
			return p1.second < p2.second;
		} else {
			return p1.first > p2.first;
		}
	}
};

调用

vector<pair<int, int>> ve;
sort(ve.begin(), ve.end(), cmp);

unordered_map

基本性质和用法和map一样，下面主要讲解一下区别。

内部实现原理

map：内部用红黑树实现，具有自动排序（按键从小到大）功能。

unordered_map：内部用哈希表实现，内部元素无序杂乱。

效率比较

map：

优点：内部用红黑树实现，内部元素具有有序性，查询删除等操作复杂度为O ( l o g N ) O(logN)O(logN)

缺点：占用空间，红黑树里每个节点需要保存父子节点和红黑性质等信息，空间占用较大。

unordered_map：

优点：内部用哈希表实现，查找速度非常快（适用于大量的查询操作）。
缺点：建立哈希表比较耗时。

multimap

键可以重复，即一个键对应多个值

默认按照less<key>升序排列

#include<iostream>
#include<map>
using namespace std;
int main()
{
    srand((unsigned)time(NULL));
    multimap<int,int>mp;
// multimap第三个参数默认为less<Key>,即 less<int>
    int n;
    cin>>n;
    int a,b;
    for(int i=0; i<n; i++)
    {
        a=rand()%4;
        b=rand()%4;
        //插入
        mp.insert(pair<int,int>(a,b));
    }
    map<int,int>::iterator iter;
    //遍历输出
    for(iter=mp.begin(); iter!=mp.end(); iter++)
        cout<<iter->first<<" "<<iter->second<<endl;
    return 0;
}

输入8，Key升序，Value随机：
1 1
1 1
1 2
2 1
3 3
3 0
3 3
3 2

用greater< Key>实现按Key值递减插入数据

multimap<int,int,greater<int> >mp;
//注意<int>后空一格

输入8，Key值降序排列，Value随机：
3 0
3 3
3 1
2 3
2 0
1 0
0 0
0 0

如果键值为自定义结构体

#include<iostream>
#include<map>
using namespace std;
struct Node
{
int x;
	int y;
	int z;
Node() {}
Node(int x, int y, int z):x(x), y(y), z(z){} //赋值
};
//自定义比较规则
//注意operator是(),不是＜
struct cmp
{
bool operator() (const Node& a,const Node& b) const //从小到大
{
if (a.x == b.x) {
			if(a.y == b.y) {
				return a.z > b.z;	// 第3顺序按z降序排列
			}
			return a.y > b.y;		// 第2顺序按y降序排列
		}
		return a.x < b.x;			// 第3顺序按x升序排列

}
};

int main()
{	int a = 0;
	int maxSize = 4;
   Node node[maxSize] = {{1,5,9}, {2, 6, 10}, {2, 9, 8}, {2,9,3}};
    //注意此处一定要有Cmp，否则无法排序会报错
    multimap<Node,int,cmp>mp;
	for(int i = 0; i < 4; i++) {
		a = rand()%4;
		mp.insert(pair<Node,int>(node[i],a));
	}

    map<Node,int>::iterator iter;
    for(iter=mp.begin(); iter!=mp.end(); iter++)
	cout<<iter->first.x<<" "<<iter->first.y<<" "<<iter->first.y<<" "<<iter->second<<endl;
    return 0;
}

inforx

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
C++STL之map和unordered_map详解

前面的STL的容器，如vector、list、deque等都是，因为（1）底层的数据结构是线性的（2）存储的是元素本身（3）数据和数据之间没有关联也是用来存储数据的，不过里面存储的是键值对，数据检索时，效率比序列式容器高。STL有两种关联式容器：树形结构和哈希结构。树形结构的关联式容器有4种：set、map 、multiset、multimap，它们的底层都是平衡搜索树（红黑树）。
复制链接

扫一扫