【C++】set和map——详细使用说明

lcj25112026-10-01 9:46

set和map

### 文章目录

  • [set和map](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [@toc](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [1. 序列式容器和关联式容器](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [1.1 序列式容器](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [1.2 关联式容器](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2. set 系列的使用](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.1 set 的介绍](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.2 set 的构造和迭代器](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [四种构造方式](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [正向迭代器和反向迭代器](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.3 插入数据和去重排序](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [insert 的三个重载](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [三种插入方式的代码](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [去重 + 升序 / 降序](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.4 查找与删除](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [find 和 count](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [erase 的三种用法](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [算法库 find 和 set::find 的对比](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.5 边界查找：lower_bound / upper_bound](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [2.6 multiset 和 set 的差异](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3. map 系列的使用](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.1 map 的介绍](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.2 pair 类型](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.3 map 的构造和迭代遍历](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.4 find / count / erase](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.5 swap 和 clear](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.6 边界查找：lower_bound / upper_bound / equal_range](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.7 insert 与它的返回值](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [insert 的四种写法](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [用返回值判断插入是否成功](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.8 修改数据与 operator\[\]](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [operator\[\] 的内部实现](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [operator\[\] 的五种情况验证](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [统计水果出现次数（find + insert 写法 vs operator\[\] 写法）](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)
  • [3.9 multimap 和 map 的差异](#文章目录 set和map @[toc] 1. 序列式容器和关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 系列的使用 2.1 set 的介绍 2.2 set 的构造和迭代器 四种构造方式 正向迭代器和反向迭代器 2.3 插入数据和去重排序 insert 的三个重载 三种插入方式的代码 去重 + 升序 / 降序 2.4 查找与删除 find 和 count erase 的三种用法 算法库 find 和 set::find 的对比 2.5 边界查找：lower_bound / upper_bound 2.6 multiset 和 set 的差异 3. map 系列的使用 3.1 map 的介绍 3.2 pair 类型 3.3 map 的构造和迭代遍历 3.4 find / count / erase 3.5 swap 和 clear 3.6 边界查找：lower_bound / upper_bound / equal_range 3.7 insert 与它的返回值 insert 的四种写法 用返回值判断插入是否成功 3.8 修改数据与 operator[] operator[] 的内部实现 operator[] 的五种情况验证 统计水果出现次数（find + insert 写法 vs operator[] 写法） 3.9 multimap 和 map 的差异)

1. 序列式容器和关联式容器

1.1 序列式容器

  • 我们之前学了string、vector、list、deque、array
    • 两个位置之间的值可以交换
    • 元素按照位置来保存和访问

1.2 关联式容器

  • Set和map还有unordered map和unordered set
    • 模具结构是非线性的，两个位置之间有紧密的关联，不能交换
    • 按关键字来保存和访问

2. set 系列的使用

2.1 set 的介绍

参考文档：https://legacy.cplusplus.com/reference/set/

  • T就是set底层关键字的类型
  • Set, 默认要求T支持小于比较。如果不支持或想按自己的需求走，就可以把仿函数放在第二个模板参数里
  • 一般情况下，剩下两个模板参数不传
  • 底层是红黑树，增删查改效率是log n级别的
  • 迭代器遍历是中序（左根右，根在中间）------>遍历得到的结果是有序的
cpp 复制代码 
template < class T,                        // set::key_type / value_type
           class Compare = less<T>,        // set::key_compare / value_compare
           class Alloc = allocator<T>      // set::allocator_type
           > class set;

2.2 set 的构造和迭代器

四种构造方式

cpp 复制代码 
// empty (1) 无参默认构造
explicit set (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());

// range (2) 迭代器区间构造
template <class InputIterator>
  set (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare(),
       const allocator_type& = allocator_type());

// copy (3) 拷贝构造
set (const set& x);

// initializer list (5) initializer 列表构造
set (initializer_list<value_type> il,
     const key_compare& comp = key_compare(),
     const allocator_type& alloc = allocator_type());
cpp 复制代码 
// TODO: 用 4 种方式各构造一个 set
//   1. 无参默认构造
//   2. 迭代器区间构造（拿一个 vector 的 begin/end）
//   3. 拷贝构造
//   4. initializer_list 构造

set<int> st1;

vector<int> v = { 22,33,66,234,333 };
set<int> st2(v.begin(), v.end());

set<int> st3 = st2;

set<int> st4({ 22,88,892,34 });

正向迭代器和反向迭代器

cpp 复制代码 
// 迭代器是一个双向迭代器
iterator   -> a bidirectional iterator to const value_type

// 正向迭代器
iterator begin();
iterator end();

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();
cpp 复制代码 
// TODO: 用正向迭代器遍历其中一个，再用反向迭代器 rbegin/rend 遍历一次

for (auto i = st3.begin(); i != st3.end(); i++)
{
	cout << *i << "<";
}

cout << endl;

for (auto i = st3.rbegin(); i != st3.rend(); i++)
{
	cout << *i << "<";
}

cout << endl;

2.3 插入数据和去重排序

insert 的三个重载

cpp 复制代码 
// 单个数据插入，如果已经存在则插入失败
pair<iterator,bool> insert (const value_type& val);

// 列表插入，已经在容器中存在的值不会插入
void insert (initializer_list<value_type> il);

// 迭代器区间插入，已经在容器中存在的值不会插入
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
cpp 复制代码 
Member types
key_type   -> The first template parameter (T)
value_type -> The first template parameter (T)

三种插入方式的代码

cpp 复制代码 
st1.insert(8);
st1.insert(2);
st1.insert(3);
st1.insert(9);
st1.insert(5);

st4.insert({ 8432,2843,3483,8483 });

st4.insert(st1.begin(), st1.end());

for (auto e : st4)
{
	cout << e << " ";
}
cout << endl;

去重 + 升序 / 降序

cpp 复制代码 
set<int> s({ 5, 2, 7, 5, 7, 3 });
for (auto e : s)
{
	cout << e << " ";
}
cout << endl;

// 去重 + 降序排序（给一个大于的仿函数）
set<int, greater<int>> s2({ 5, 2, 7, 5, 7, 3 });
for (auto e : s2)
{
	cout << e << " ";
}
cout << endl;

set<string> s3({ "sort", "insert", "add" });
for (auto e : s3)
{
	cout << e << " ";
}
cout << endl;

2.4 查找与删除

find 和 count

cpp 复制代码 
// 查找 val，返回 val 所在的迭代器，没有找到返回 end()
iterator find (const value_type& val);

// 查找 val，返回 val 的个数
size_type count (const value_type& val) const;
cpp 复制代码 
if (st4.find(8848) != st4.end())
{
	cout << "找到了8848" << endl;
}
else
	cout << "没找到8848" << endl;

cout << "3的个数为：";
cout << st4.count(3) << endl;

erase 的三种用法

cpp 复制代码 
// 删除一个迭代器位置的值
iterator  erase (const_iterator position);

// 删除 val，val 不存在返回 0，存在返回 1
size_type erase (const value_type& val);

// 删除一段迭代器区间的值
iterator  erase (const_iterator first, const_iterator last);
cpp 复制代码 
set<int> s = { 4,2,7,2,8,5,9 };

for (auto e : s)
{
	cout << e << " ";
}
cout << endl;

// 删掉最小值
s.erase(s.begin());
for (auto e : s)
{
	cout << e << " ";
}
cout << endl;

// 从键盘读一个 x，用 find 拿到迭代器，找到了就 erase 掉，没找到提示"不存在"
cout << "请输入一个你想删除的值：";
int x;
cin >> x;

if (s.find(x) != s.end())
{
	s.erase(s.find(x));
}
else
	cout << "不存在你输入的值" << endl;

// 打印一遍 s
for (auto e : s)
{
	cout << e << " ";
}

cout << endl;
cout << endl;

cout << endl << endl << "原本st4的内容为：" << endl;
for (auto e : st4)
{
	cout << e << " ";
}

st4.erase(st4.find(3), st4.find(2843));
cout << "删除3到2843之间的值" << endl;

cout << endl << endl << "现在st4的内容为：" << endl;
for (auto e : st4)
{
	cout << e << " ";
}

算法库 find 和 set::find 的对比

cpp 复制代码 
// 再读一个 x，用 count 间接实现快速查找并打印提示
cout << "please input a value you want to find:  ";
cin >> x;
if (s.count(x))
	cout << " yes we have it" << endl;
else
	cout << "no we don't have it" << endl;

// TODO: 写出两种查找的对比：
//   算法库的 find（O(N)）和 set 自身的 find（O(logN)）

// 算法库的查找 O(N)
auto pos1 = find(s.begin(), s.end(), x);
// set 自身实现的查找 O(logN)
auto pos2 = s.find(x);
// 利用 count 间接实现快速查找
cin >> x;
if (s.count(x))
{
	cout << x << "在！" << endl;
}
else
{
	cout << x << "不存在！" << endl;
}

2.5 边界查找：lower_bound / upper_bound

cpp 复制代码 
// 返回大于等于 val 位置的迭代器
iterator lower_bound (const value_type& val) const;

// 返回大于 val 位置的迭代器
iterator upper_bound (const value_type& val) const;
cpp 复制代码 
cout << "大于等于3位置的值为：" << *(st4.lower_bound(3)) << endl;

cout << "大于 3位置的值为：" << *(st4.upper_bound(3)) << endl;
cpp 复制代码 
std::set<int> myset;

// TODO: 用循环往 myset 里插入 i * 10（i 从 1 到 9），得到 10 20 ... 90
for (int i = 1; i < 10; i++)
{
	myset.insert(i * 10);
}

// TODO: 打印一遍
cout << "打印一遍：";
for (auto e : myset)
{
	cout << e << " ";
}

// TODO: 用 lower_bound 和 upper_bound 拿到要删除区间的两个边界
//       目标：删掉 30 ~ 50 这一段
//       想一想：右边界应该用哪个函数？为什么不是 lower_bound(50)？

auto first = myset.lower_bound(30);
auto last = myset.upper_bound(50);

// TODO: 用 erase(first, last) 删掉这段区间，再打印一遍
myset.erase(first, last);

cout << "删除掉30 到50之间的数之后：";
for (auto e : myset)
{
	cout << e << " ";
}
cpp 复制代码 
std::set<int> myset;
for (int i = 1; i < 10; i++)
	myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
for (auto e : myset)
{
	cout << e << " ";
}
cout << endl;

// 实现查找到的[itlow,itup)包含[30, 60]区间

// 返回 >= 30
auto itlow = myset.lower_bound(30);
// 返回 > 60
auto itup = myset.upper_bound(60);
// 删除这段区间的值
myset.erase(itlow, itup);
for (auto e : myset)
{
	cout << e << " ";
}
cout << endl;

2.6 multiset 和 set 的差异

cpp 复制代码 
multiset<int> ms({ 4,2,7,2,4,8,4,5,4,9 });
cout << "now we have nums: ";
for (auto e : ms)
{
	cout << e << " ";
}
cout << endl;

// 从键盘读一个 x，用 find 找到后，从它开始往后把所有 == x 的都打印出来
cout << "please input a number to find: ";
int x;
cin >> x;
cout << endl;

// 用 count 打印 x 的实际个数
cout << "the num we have the num you input: " << ms.count(x) << endl << endl;

// 用 erase(x) 直接把所有 x 都删掉，再遍历打印
cout << "now we delete all the num you input :" << endl;
ms.erase(x);
for (auto e : ms)
{
	cout << e << " ";
}
cpp 复制代码 
// 相比set不同的是，multiset是排序，但是不去重
multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
auto it = s.begin();
while (it != s.end())
{
	cout << *it << " ";
	++it;
}
cout << endl;

// 相比set不同的是，x可能会存在多个，find查找中序的第一个
int x;
cin >> x;
auto pos = s.find(x);
while (pos != s.end() && *pos == x)
{
	cout << *pos << " ";
	++pos;
}
cout << endl;
// 相比set不同的是，count会返回x的实际个数
cout << s.count(x) << endl;
// 相比set不同的是，erase给值时会删除所有的x
s.erase(x);
for (auto e : s)
{
	cout << e << " ";
}
cout << endl;

3. map 系列的使用

3.1 map 的介绍

参考文档：https://legacy.cplusplus.com/reference/map/

cpp 复制代码 
template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

3.2 pair 类型

cpp 复制代码 
typedef pair<const Key, T> value_type;

template <class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;

	T1 first;
	T2 second;

	pair()
		: first(T1()), second(T2())
	{}

	pair(const T1& a, const T2& b)
		: first(a), second(b)
	{}

	template<class U, class V>
	pair(const pair<U, V>& pr)
		: first(pr.first), second(pr.second)
	{}
};

template <class T1, class T2>
inline pair<T1, T2> make_pair(T1 x, T2 y)
{
	return (pair<T1, T2>(x, y));
}
cpp 复制代码 
// TODO: 不写代码，先在注释里回答：
//       1. map 的 key_type / mapped_type / value_type 分别是什么类型？
//       2. pair 的两个成员叫什么？
//       3. make_pair 和直接构造 pair 有什么区别？

3.3 map 的构造和迭代遍历

cpp 复制代码 
// empty (1) 无参默认构造
explicit map (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());

// range (2) 迭代器区间构造
template <class InputIterator>
  map (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare(),
       const allocator_type& = allocator_type());

// copy (3) 拷贝构造
map (const map& x);

// initializer list (5) initializer 列表构造
map (initializer_list<value_type> il,
     const key_compare& comp = key_compare(),
     const allocator_type& alloc = allocator_type());
cpp 复制代码 
// 1. 【建议】显式加一句 #include<string>。现在 MSVC 能过是因为 <map> 间接把 string 带进来了，
//           但换 g++ / Linux 大概率报"不完整类型"。这种依赖间接包含的写法别养成习惯。
#include<string>

// 用 initializer_list 构造一个 map<string, string>
map<string, string> m({ { "left","左边" },{ "right", "右边" } });

// 用迭代器遍历，打印 key 和 value
auto i = m.begin();
while (i != m.end())
{
	cout << i->first << ":" << i->second << endl;
	i++;
	// 1. 【要改】循环体里漏了 ++i。迭代器一直不往前走，i 就永远 != m.end()，
	//           只要 m 非空就会无限循环刷屏。（m 为空时才碰巧能退出。）
	// 1. 【改成】在循环体最后补一句 ++i;
}

// 试着改一下 value，再试一下改 key，看哪个能编译过
for (auto e : m)
{
	cout << e.first << e.second << endl;
	/*e.first = "eis";
	e.second = "eis";*/
}
cpp 复制代码 
// map<string, string>::iterator it = dict.begin();
auto it = dict.begin();

while (it != dict.end())
{
	// cout << (*it).first << ":" << (*it).second << endl;

	// map 的迭代基本都使用 operator->
	// 第一个 -> 是迭代器运算符重载，返回 pair*；第二个箭头是结构指针解引用取 pair 数据
	// cout << it.operator->()->first << ":" << it.operator->()->second << endl;

	cout << it->first << ":" << it->second << endl;
	++it;
}
cout << endl;

// 范围 for 遍历
for (const auto& e : dict)
{
	cout << e.first << ":" << e.second << endl;
}
cout << endl;

3.4 find / count / erase

cpp 复制代码 
// 查找 k，返回 k 所在的迭代器，没有找到返回 end()
iterator find (const key_type& k);

// 查找 k，返回 k 的个数
size_type count (const key_type& k) const;

// 删除一个迭代器位置的值
iterator  erase (const_iterator position);

// 删除 k，k 不存在返回 0，存在返回 1
size_type erase (const key_type& k);

// 删除一段迭代器区间的值
iterator  erase (const_iterator first, const_iterator last);
cpp 复制代码 
map<string, string> dict = { { "left","左边" }, { "right","右边" } };

// TODO: 用 find 找一个 key，打印它的 value
// TODO: 用 count 判断一个 key 在不在
// TODO: 用 key 直接 erase 一个元素
// TODO: 用迭代器位置 erase 一个元素

auto it = dict.find("left");
cout << it->second << endl;

if (dict.count("right"))
	cout << "right在" << endl;
else
	cout << "right不在" << endl;

dict.erase("right");
if (dict.count("right"))
	cout << "right在" << endl;
else
	cout << "right不在" << endl;

dict.erase(dict.find("left"));
if (dict.count("left"))
	cout << "left在" << endl;
else
	cout << "left不在" << endl;
cpp 复制代码 
map<string, string> dict = { {"left", "左边"}, {"right", "右边"} };

// TODO: 插入一个已存在的 key，value 故意写不一样，看看结果------>没有变化
dict.insert({ "left","jjjjj" });
for (const auto& e : dict)
{
	cout << e.first << " " << e.second << endl;
}

// TODO: 用 find 找一个存在的 key，通过迭代器把它的 value 改掉
auto a = dict.find("left");
a->second = "hahah";

// 1. 【漏写】这两块 TODO 还空着，没动。
// 1. 【补齐】count 判断 key 在不在、erase(k) 删掉一个 key，各写一段再跑一遍
// 2. 【提示】你已经用到了 count；先想办法单独展示 key 在与不在两种判断结果，再考虑删除。
// TODO: 用 count 判断一个 key 在不在
if (dict.count("right"))
	dict.erase("right");

for (const auto& e : dict)
{
	cout << e.first << " " << e.second << endl;
}

// 2. 【提示】上面的 erase 已经执行了，但这条 TODO 后面仍是空的；把判断和删除的步骤理清，并观察删除前后集合的变化。
// TODO: 用 erase(k) 删掉一个 key

3.5 swap 和 clear

cpp 复制代码 
map<string, string> d1 = { { "a","1" } };
map<string, string> d2 = { { "b","2" }, { "c","3" } };

auto it = d1.begin();
while (it != d1.end())
{
	cout << it->first << ":" << it->second << endl;
	++it;
}

it = d2.begin();
while (it != d2.end())
{
	cout << it->first << ":" << it->second << endl;
	++it;
}

// TODO: 用 swap 交换 d1 和 d2，分别打印看结果
swap(d1, d2);
it = d1.begin();
while (it != d1.end())
{
	cout << it->first << ":" << it->second << endl;
	++it;
}

it = d2.begin();
while (it != d2.end())
{
	cout << it->first << ":" << it->second << endl;
	++it;
}

// TODO: 对其中一个调 clear()，再打印看结果
d1.clear();

it = d1.begin();
while (it != d1.end())
{
	cout << it->first << ":" << it->second << endl;
}

3.6 边界查找：lower_bound / upper_bound / equal_range

cpp 复制代码 
// 返回大于等于 k 位置的迭代器
iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const;

// 返回大于 k 位置的迭代器
iterator upper_bound (const key_type& k);

// 返回 k 所在的区间 [first, second)
pair<iterator,iterator> equal_range (const key_type& k);
cpp 复制代码 
map<int, string> m = { {10,"a"},{20,"b"},{30,"c"},{40,"d"} };

// TODO: 用 lower_bound 和 upper_bound 分别拿一个边界迭代器，打印它们的 key
// TODO: 拿一个不存在的 key 试一下，看两个接口分别返回谁
cout << m.lower_bound(10)->second << endl;
cout << m.upper_bound(10)->second << endl;

cout << m.lower_bound(11)->second << endl;
cout << m.upper_bound(11)->second << endl;
return 0;
cpp 复制代码 
map<char, int> m = { {'A',10},{'B',20},{'C',30} };

// TODO: 用 equal_range 给一个 key，拿到它返回的那对区间迭代器
//       想一下：为什么这里要用 auto 接？
//       想一下：给 'B' 的时候，区间的左右边界分别指向谁？

auto ans = m.equal_range('B');
cout << ans.first->second << endl;
cout << ans.second->second << endl;
return 0;

3.7 insert 与它的返回值

insert 的四种写法

cpp 复制代码 
// 单个数据插入，如果 key 已经存在则插入失败，
// key 存在、value 不相等也会插入失败
pair<iterator,bool> insert (const value_type& val);

// 列表插入，已经在容器中存在的值不会插入
void insert (initializer_list<value_type> il);

// 迭代器区间插入，已经在容器中存在的值不会插入
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
cpp 复制代码 
// insert 插入 pair 对象的 4 种方式，对比之下，最后一种最方便
pair<string, string> kv1("first", "第一个");
dict.insert(kv1);
dict.insert(pair<string, string>("second", "第二个"));
dict.insert(make_pair("sort", "排序"));
dict.insert({ "auto", "自动的" });

// "left" 已经存在，插入失败
dict.insert({ "left", "左边，剩余" });

// 范围 for 遍历
for (const auto& e : dict)
{
	cout << e.first << ":" << e.second << endl;
}
cout << endl;

string str;
while (cin >> str)
{
	auto ret = dict.find(str);
	if (ret != dict.end())
	{
		cout << "->" << ret->second << endl;
	}
	else
	{
		cout << "无此单词，请重新输入" << endl;
	}
}

// erase 等接口跟 set 完全类似，这里就不演示讲解了
return 0;

用返回值判断插入是否成功

  • Insert插入一个 pair<iterator,bool>对象

    • 插入成功或失败，first返回的都是key所在的迭代器
    • 插入成功second返回true，插入失败second返回false

  • 既然first返回的是key所指向的迭代器，那么就实现了查找的功能，因此insert可以用来实现operator

cpp 复制代码 
map<string, string> dict = { { "left","左边" } };

// TODO: 插一个不存在的 key，把 insert 的返回值接住，打印它的 second 和 first->first
auto it = dict.insert({ "right" ,"右边" });
cout << dict["right"] << endl;
/*cout << it.first << ":" << it.second << endl;*/
cout << it.second << endl;
cout << it.first->first << ":" << it.second << endl;

// TODO: 再插一个已存在的 key，同样接住返回值，打印 second 和 first->first
it = dict.insert({ "left","hhhhhh" });
cout << it.second;
cout << it.first->first << endl;

// TODO: 对比两次结果，说出 insert 在什么情况下充当了查找

3.8 修改数据与 operator\[\]

operator\[\] 的内部实现

cpp 复制代码 
mapped_type& operator[] (const key_type& k);
cpp 复制代码 
// operator的内部实现
mapped_type& operator[] (const key_type& k)
{
	// 1、如果k不在map中，insert会插入k和mapped_type默认值，同时[]返回结点中存储
	// mapped_type值的引用，那么我们可以通过引用修改返回映射值。所以[]具备了插入+修改功能
	// 2、如果k在map中，insert会插入失败，但是insert返回pair对象的first是指向key结点的
	// 迭代器，同时[]返回结点中存储mapped_type值的引用，所以[]具备了查找+修改的功能
	pair<iterator, bool> ret = insert({ k, mapped_type() });
	iterator it = ret.first;
	return it->second;
}

operator\[\] 的五种情况验证

cpp 复制代码 
map<string, string> dict;

// TODO: 先用 make_pair 插一个 { "sort", "排序" }dict
auto p = make_pair("a", "b");
dict.insert(p);
dict.insert(make_pair("sort", "排序"));

// TODO: 情况一：只写 dict["insert"]; 不赋值 ------ 打开调试看看 map 里多了什么
dict["insert"];
// TODO: 情况二：给一个不存在的 key 赋值 ------ 这是插入 + 修改
dict["this"] = "is";

// TODO: 情况三：给刚才那个 key 再赋一次值 ------ 这是单纯修改
dict["this"] = "is not";
// TODO: 情况四：cout 一个已存在的 key ------ 这是查找
cout << dict["this"] << endl;

// TODO: 情况五：cout 一个不存在的 key ------ 观察返回什么，想想是哪种功能
cout << dict["that"] << endl;
return 0;
cpp 复制代码 
map<string, string> dict;
dict.insert(make_pair("sort", "排序"));
// key不存在->插入 {"insert", string()}
dict["insert"];
// 插入+修改
dict["left"] = "左边";
// 修改
dict["left"] = "左边、剩余";
// key存在->查找
cout << dict["left"] << endl;
return 0;

统计水果出现次数（find + insert 写法 vs operator\[\] 写法）

cpp 复制代码 
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉" };

// TODO: 定义 map<string, int> countMap
map<string, int> countMap;

// TODO: 用范围 for 遍历 arr 的每个元素
//       先用 find 判断在不在
//       不在 → 插入 {水果, 1}
//       在   → 把找到的节点里的次数 ++
for (auto e : arr)
{
	auto a = countMap.find(e);
	if (a == countMap.end())
	{
		countMap.insert({ e,1 });
	}
	else
		a->second++;
}

// TODO: 遍历 countMap 打印 水果:次数
for (auto e : countMap)
{
	cout << e.first << ":" << e.second << endl;
}
cpp 复制代码 
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉" };

// 利用[]插入+修改功能，巧妙实现统计水果出现的次数
map<string, int> countMap;
for (const auto& str : arr)
{
	// []先查找水果在不在map中
	// 1、不在，说明水果第一次出现，则插入{水果, 0}，同时返回次数的引用，++一下就变成1次了
	// 2、在，则返回水果对应的次数++
	countMap[str]++;
}
for (const auto& e : countMap)
{
	cout << e.first << ":" << e.second << endl;
}
cout << endl;

3.9 multimap 和 map 的差异

cpp 复制代码 
// TODO: 定义一个 multimap<string, string> dict
multimap<string, string> dict;
// TODO: 插入多条 key 相同的记录，value 各不相同，看是不是都能进去
dict.insert({ "this","is" });
dict.insert({ "this","is not" });
dict.insert({ "this","will" });
dict.insert({ "this","will be" });
dict.insert({ "this","was" });
// TODO: 再插一条 key 不同的
dict.insert({ "that","is" });
// TODO: 用 erase(key) 把那个重复的 key 一次全删掉
dict.erase("this");
// TODO: 打开调试，在监视窗口里观察底层树被 VS 展开后的样子
cpp 复制代码 
multimap<char, int> m = { {'A',10},{'B',20},{'B',30},{'B',40},{'C',50} };

// TODO: 对 key 'A' 调 equal_range，用 auto 接住
//       遍历这个区间，打印每个元素的 first 和 second
auto a = m.equal_range('A');
auto it = a.first;
while (it != a.second)
{
	cout << it->first << ":" << it->second << endl;
	it++;
}
// TODO: 换成 key 'B' 再来一次，观察区间里是不是有 3 个元素
a = m.equal_range('B');
it = a.first;
while (it != a.second)
{
	cout << it->first << ":" << it->second << endl;
	it++;
}
// TODO: 用 find 拿到中序第一个 B，再手动往后 ++ ，对比一下两种写法
it = m.find('B');
while (it != m.end())
{
	cout << it->first << ":" << it->second << endl;
	it++;
}
return 0;
相关推荐
潼心1412o1 小时前
C++初阶（长期更新）第3讲：类和对象（中）
开发语言·c++
外收内放1 小时前
Python基础语法练习题（40-42）
开发语言·python
程序喵大人1 小时前
【C++入门】编译链接模型 - 02 预处理把头文件怎样塞进源文件
开发语言·c++·预处理·编译链接·头文件·源文件
茉莉玫瑰花茶2 小时前
GO [ 并发 · 调度器 ]
开发语言·后端·golang
zhangzeyuaaa2 小时前
深入理解 Ruby 可变对象与不可变对象的原理、坑点与最佳实践
开发语言·后端·ruby
艾莉丝努力练剑2 小时前
【AI大模型接入SDK】ChatSDK 集成测试概述
jvm·c++·人工智能·学习·面试·集成测试·sdk
新鲜势力呀2 小时前
PHP 实战：第三方接口经常超时怎么办？从API调用优化到服务稳定性完整方案
开发语言·php
艾莉丝努力练剑2 小时前
【AI大模型接入SDK】ChatSDK：CMake构建静态库完整实现
java·开发语言·网络·c++·人工智能·学习·sdk
热门推荐
01历年考研数学一、数学二、数学三真题试卷及答案PDF02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03GitHub 镜像站点04Telegram APK 下载安装完整指南 — 2026年最新05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接062026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享07微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新08jev-ultrafast 深度解析：7 秒订机票的浏览器 Agent 是如何炼成的09给AI一张“业务概念地图“：本体如何从哲学走向企业智能10Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）