【C++】C++ set 与 multiset 完全指南：关联式容器入门

原创于 2026-06-16 16:44:33 发布 · 423 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++ #开发语言 #学习 #笔记 #其他

C++ 专栏收录该内容

28 篇文章

订阅专栏

📌 相关专栏

📌 相关文章推荐

很高兴你点开这篇文章✨

这里会持续更新更多有用的内容，关注我，一起慢慢变好呀

👍 点赞 ⭐ 收藏 💬 评论

文章目录

前言
set 与 multiset 核心特点
1. 序列式容器 vs 关联式容器
- 1.1 序列式容器
- 1.2 关联式容器
2. set 类概述
3 初始化与插入：去重 + 自动排序
4. set 的插入、查找与删除
5. set 的区间操作：lower_bound 与 upper_bound
- 5.1 接口说明
- 5.2 区间删除示例
6. multiset：允许重复元素的 set
- 6.1 multiset 与 set 的区别
- 6.2 multiset 示例
7. 总结
本文全部代码
- 🐾 Test.cpp

前言

在学习了 vector、list 等序列式容器后，我们将进入 STL 的另一大类别——关联式容器。

前⾯我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，这些容器统称为“序列式容器”，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间⼀般没有紧密的关联关系，⽐如交换⼀下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的
“关联式容器”也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是“⾮线性结构”，两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。

特性	序列式容器	关联式容器
`存储逻辑`	线性序列	非线性结构（树/哈希）
`访问方式`	按位置访问	按关键字访问
`元素关系`	松散，交换位置不影响结构	紧密，交换会破坏结构
`典型代表`	`vector、list、deque`	`set、map、unordered_set`

set 与 multiset 核心特点

容器	底层结构	元素唯一性	是否有序	时间复杂度
`set`	红黑树	唯一	升序	O(log n)
`multiset`	红黑树	可重复	升序	O(log n)

🐶 🐾 ✨ 🐾 🐶

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

1.1 序列式容器

前面学过的 string、vector、list、deque 等都属于序列式容器：

逻辑结构为线性序列
元素按存储位置顺序保存和访问
交换两个元素，容器性质不变

1.2 关联式容器

set、map 系列和 unordered_set、unordered_map 系列属于关联式容器：

逻辑结构通常是非线性结构（树/哈希表）
元素按关键字保存和访问
元素之间有紧密的关联关系

核心区别：数据如何存储与访问——序列式按位置，关联式按关键字。

🐶 🐾 ✨ 🐾 🐶

2. set 类概述

2.1 模板声明

T就是 set 底层关键字的类型
set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数
set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。
一般情况下，我们都不需要传后两个模版参数。
set底层是用红黑树实现，增删查效率是O(logN)，迭代器遍历是走的搜索树的中序，所以是有序的

template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // 比较函数（默认升序）
           class Alloc = allocator<T>      // 空间配置器
           > class set;

2.2 set 的核心特性

特性	说明
`自动排序`	插入元素后自动按 key 排序（默认升序）
`去重`	不允许存储重复的 key
`不可修改`	key 迭代器是 const_iterator，无法通过迭代器修改
`高效操作`	增删查均为 O(log n)
`双向迭代器`	支持 ++ 和 --，不支持随机访问

2.3 构造相关接口

// 1. 无参默认构造
set<int> s1;

// 2. 迭代器区间构造
set<int> s2(v.begin(), v.end());

// 3. 拷贝构造
set<int> s3(s2);

// 4. initializer_list 构造（C++11）
set<int> s4({1, 2, 3, 4, 5});
set<int> s5 = {1, 2, 3, 4, 5};

// 迭代器是⼀个双向迭代器
iterator -> a bidirectional iterator to const value_type

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

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();

1. empty: ⽆参默认构造

explicit set (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());

2. range : 迭代器区间构造

template <class InputIterator>
set (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());

3. copy ：拷⻉构造

set (const set& x);

4. initializer list ：列表构造

set (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());

2.4 set的增删查相关接口

Member types
key_type -> The first template parameter (T)
value_type -> The first template parameter (T)

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

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

// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);

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

// 查找val，返回Val的个数
size_type count (const value_type& val) const;

// 删除⼀个迭代器位置的值，返回的是下一个位置的迭代器
iterator erase (const_iterator position);

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

// 删除⼀段迭代器区间的值
iterator erase (const_iterator first, const_iterator last);

// 返回第一次出现⼤于等于val位置的迭代器
iterator lower_bound (const value_type& val) const;

// 返回第一次出现⼤于val位置的迭代器
iterator upper_bound (const value_type& val) const;

🐶 🐾 ✨ 🐾 🐶

3 初始化与插入：去重 + 自动排序

3.1 单个元素插入

void test_set1()
{
    set<int> s1;
    
    //方式1： 单个元素插入
    s1.insert(3);
    s1.insert(1);
    s1.insert(2);
    s1.insert(5);
    s1.insert(3);   // 重复元素，不会被插入
    s1.insert(5);   // 重复元素，不会被插入
    s1.insert(6);
    
    // 遍历方式1：  迭代器
    auto it = s1.begin();
    while (it != s1.end())
    {
        // *it = 1;  //  不能修改！迭代器是 const_iterator
        cout << *it << " ";
        it++;
    }
    cout << endl;   // 输出：1 2 3 5 6（去重+有序）
}

3.2 初始化列表批量插入

void test_set1()
{
    // 方式2：初始化列表批量插入
    set<int> s2;
    s2.insert({3, 1, 2, 5, 3, 5, 6});
    
    // 遍历方式2：范围 for
    for (auto& e : s2)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 3 5 6
}

3.3 自定义排序（降序）

void test_set1()
{
    // 降序排序：使用 greater<int> 仿函数
    set<int, greater<int>> s3({3, 1, 2, 5, 3, 5, 6});
    
    for (auto& e : s3)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：6 5 3 2 1
}

🐾 代码执行

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;

void test_set1()
{
	//测试set的插入与遍历（去重 + 自动排序）
	set<int> s1;

// 方式1：单个元素插入
	s1.insert(3);
	s1.insert(1);
	s1.insert(2);
	s1.insert(5);
	s1.insert(3);
	s1.insert(5);
	s1.insert(6);

	cout << "s1" << endl;

	// 遍历方式1：迭代器遍历（注意：*it不可修改）
	// 遍历结果: 去重+有序
	auto it = s1.begin();
	while (it != s1.end())
	{
		//*it1 = 1;//不能修改
		cout << *it << " ";
		it++;
	}
	cout << endl;

// 方式2：初始化列表批量插入
	set<int> s2;
	s2.insert({ 3,1,2,5,3,5,6 });

	cout << "s2" << endl;
	// 遍历方式2：范围for循环
	for (auto& e : s2)
	{
		cout << e << " ";
	}
	cout << endl;

	//若需降序排序，可指定排序仿函数：set<int, greater<int>> s -> 降序排序
	set<int, greater<int>> s3({ 3,1,2,5,3,5,6 }); //列表构造

	cout << "s3" <<endl;

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

int main()
{
	test_set1();
}

🐶 🐾 ✨ 🐾 🐶

4. set 的插入、查找与删除

4.1 核心接口

接口	作用	返回值
`insert(val)`	插入单个元素	pair<iterator,bool>（是否成功）
`find(val)`	查找元素	迭代器（找不到返回 end()）
`count(val)`	统计元素个数	set 中返回 0 或 1
`erase(val)`	删除指定值	删除个数（0 或 1）
`erase(pos)`	删除迭代器位置	下一个位置的迭代器

4.2 查找与删除示例

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;

void test_set2()
{
	set<int> s1;
	s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6

	// 1.删除最小值 
	s1.erase(s1.begin());//iterator erase (const_iterator position);
	for (auto& e : s1)
	{
		cout << e << " ";
	}
	cout << endl;

	// 2.直接删除x 
	int x;
	cin >> x;
	int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
	//size_type erase(const value_type & val);
	if (num == 0)
	{
		cout << x << "不存在！" << endl;
	}
	else
	{
		cout << x << "删除成功！" << endl;
	}
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;

	// 3.直接查找在利用返回值是迭代器删除x 
	set<int> s2({ 3,1,2,5,3,5,6 });
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;

	cin >> x;
	auto pos = s2.find(x);
	if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
	{
		s2.erase(pos);
		//cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
	}
	else
	{
		cout << x << "不存在！" << endl;
	}
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;
}

int main()
{
	test_set2();
}

🐾 输入的数都存在的情况：

🐾 输入的数都不存在的情况：

4.3 find 的效率：set vs 算法库

// 算法库的 find：O(N) 线性查找
auto pos1 = find(s2.begin(), s2.end(), x);

// set 自带的 find：O(log N) 红黑树查找
auto pos2 = s2.find(x);

// 使用 count 快速判断元素是否存在
if (s2.count(x))
    cout << x << "在！" << endl;
else
    cout << x << "不在！" << endl;

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<set>

void test_set2()
{
	set<int> s1;
	s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6

	// 1.删除最小值 
	s1.erase(s1.begin());//iterator erase (const_iterator position);
	for (auto& e : s1)
	{
		cout << e << " ";
	}
	cout << endl;

	// 2.直接删除x 
	int x;
	cin >> x;
	int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
	//size_type erase(const value_type & val);
	if (num == 0)
	{
		cout << x << "不存在！" << endl;
	}
	else
	{
		cout << x << "删除成功！" << endl;
	}
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;

	// 3.直接查找在利用返回值是迭代器删除x 
	set<int> s2({ 3,1,2,5,3,5,6 });
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;

	cin >> x;
	auto pos = s2.find(x);
	if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
	{
		s2.erase(pos);
		//cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
	}
	else
	{
		cout << x << "不存在！" << endl;
	}
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;


	// 算法库的查找 O(N) 
	auto pos1 = find(s2.begin(), s2.end(), x);
	// set⾃⾝实现的查找 O(logN) 
	auto pos2 = s2.find(x);

	// 利用count间接实现快速查找 
	cin >> x;
	if (s2.count(x))
	{
		cout << x << "在！" << endl;
	}
	else
	{
		cout << x << "不在！" << endl;
	}
}

int main()
{
	test_set2();
}

结论：对于关联式容器，优先使用容器自带的 find 方法（O(log n)），而不是算法库的 find（O(n)）。

🐶 🐾 ✨ 🐾 🐶

5. set 的区间操作：lower_bound 与 upper_bound

5.1 接口说明

lower_bound(val) ：返回第一个 ≥ val 的迭代器
upper_bound(val) ：返回第一个 > val 的迭代器

5.2 区间删除示例

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;

void test_set3()
{
    set<int> s;
    s.insert({3, 1, 2, 5, 3, 5, 6, 7, 9});
    // 当前 set：1 2 3 5 6 7 9
    
    // 需求：删除 [3, 8] 区间的元素（即 ≥3 且 ≤8）
    auto it1 = s.lower_bound(3);   // 指向 3
    auto it2 = s.upper_bound(8);   // 指向 9（第一个 >8 的元素）
    
    // 删除区间 [it1, it2) → 删除 3,5,6,7
    s.erase(it1, it2);
    
    for (auto& e : s)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 9
}

int main()
{
	test_set3();
}

🐾 图示：

🐶 🐾 ✨ 🐾 🐶

6. multiset：允许重复元素的 set

6.1 multiset 与 set 的区别

特性	set	multiset
`元素唯一性`	唯一，自动去重	可重复
`insert 重复值`	插入失败	插入成功
`count(val)`	返回 0 或 1	返回实际个数
`erase(val)`	删除 0 或 1 个	删除所有匹配元素
`find(val)`	返回唯一迭代器	返回中序第一个

6.2 multiset 示例

void test_multiset()
{
    multiset<int> s1;
    s1.insert({3, 1, 2, 5, 3, 5, 6, 3, 3});
    
    // 1. 遍历：有序且保留重复元素
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 3 3 3 3 5 5 6
    
    // 2. find：返回中序第一个匹配元素的迭代器
    int x;
    cin >> x;   // 假设输入 3
    auto pos = s1.find(x);
    
    // 打印所有值为 x 的元素
    while (pos != s1.end() && *pos == x)
    {
        cout << *pos << " ";
        pos++;
    }
    cout << endl;   // 输出：3 3 3 3
    
    // 3. count：返回实际个数
    cout << x << ":" << s1.count(x) << "个" << endl;  // 输出：3:4个
    
    // 4. erase(值)：删除所有匹配元素
    cout << x << "删除的个数：" << s1.erase(x) << endl;  // 输出：4
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 5 5 6
}

int main()
{
	test_multiset();
}

🐶 🐾 ✨ 🐾 🐶

7. 总结

🐾 set 与 multiset 的核心知识点：

分类	核心内容
`关联式容器`	按关键字访问，底层红黑树
`set`	唯一 + 有序，不可修改 key
`multiset`	可重复 + 有序
`时间复杂度`	插入/删除/查找 O(log n)
`区间操作`	lower_bound / upper_bound 配合 erase
`效率对比`	set::find O(log n) vs std::find O(n)

🐾 set vs multiset 接口差异

接口	set	multiset
`insert`	重复值	插入失败插入成功
`count(val)`	返回 0/1	返回实际个数
`erase(val)`	删除 0/1 个	删除所有匹配元素
`find(val)`	返回唯一位置	返回中序第一个

🐾 使用场景

场景	推荐容器
`需要去重 + 有序`	set
`需要有序 + 允许重复`	multiset
`需要快速查找 + 不关心顺序`	unordered_set
`需要键值对映射`	map / unordered_map

🐶 🐾 ✨ 🐾 🐶

本文全部代码

🐾 Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;


/*
1.序列式容器和关联式容器
	（1）前⾯我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，
这些容器统称为“序列式容器”，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间⼀般没有紧密的关联关系，
⽐如交换⼀下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的。

	（2）“关联式容器”也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是“⾮线性结构”，
两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。

	（3）顺序容器中的元素是按关键字来保存和访问的。
	（4）关联式容器有map/set系列和unordered_map/unordered_set系列。
	（5）map和set底层是红⿊树，红⿊树是⼀颗平衡⼆叉搜索树。
	（6）set是key搜索场景的结构，map是key/value搜索场景的结构。

2.STL容器的本质区别：数据如何存储与访问

3.set类介绍：

容器				底层结构			元素唯一性		是否有序			头文件				典型时间复杂度

set				红黑树（平衡二叉搜索树）	唯一		有序（默认升序）	<set>				插入/删除/查找：O(log n)
multiset			红黑树					可重复		有序				<set>				插入/删除/查找：O(log n)
unordered_set		哈希表					唯一		无序				<unordered_set>		插入/删除/查找：平均O(1)，最坏O(n)
unordered_multiset	哈希表					可重复		无序				<unordered_set>		插入/删除/查找：平均O(1)，最坏O(n)

4.红黑树赋能的高效特性：

	- 自动排序：红黑树的中序遍历结果为有序序列，因此 set 插入元素后会自动按 key 的默认规则（less升序）排序，
	无需手动调用排序函数，如果需要按自己的需求比较可以自行实现仿函数传给第二个模板参数。

	- 去重与允许重复：set 不允许存储重复 key（multiset 支持重复 key）；

	- 不可修改 key：set 的迭代器为 const_iterator，无法通过迭代器修改 key（修改会破坏红黑树结构）；

	- 高效操作：增删查操作的时间复杂度均为O(log N)，远优于 vector 的O(N)
*/

/*
1.set的声明如下：

- T就是 set 底层关键字的类型
- set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数
- set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。
- 一般情况下，我们都不需要传后两个模版参数。
- set底层是用红黑树实现，增删查效率是O(logN)，迭代器遍历是走的搜索树的中序，所以是有序的。

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.set构造相关接口：

// 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());

// 迭代器是⼀个双向迭代器
iterator -> a bidirectional iterator to const value_type

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

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();



3.set的增删查相关接口：

Member types
key_type -> The first template parameter (T)
value_type -> The first template parameter (T)

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

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

// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);

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

// 查找val，返回Val的个数
size_type count (const value_type& val) const;

// 删除⼀个迭代器位置的值，返回的是下一个位置的迭代器
iterator erase (const_iterator position);

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

// 删除⼀段迭代器区间的值
iterator erase (const_iterator first, const_iterator last);

// 返回第一次出现⼤于等于val位置的迭代器
iterator lower_bound (const value_type& val) const;

// 返回第一次出现⼤于val位置的迭代器
iterator upper_bound (const value_type& val) const;

*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------接口实战------------------------------------------------------

// 1.初始化与插入：去重 + 自动排序
void test_set1()
{
	//测试set的插入与遍历（去重 + 自动排序）
	set<int> s1;

// 方式1：单个元素插入
	s1.insert(3);
	s1.insert(1);
	s1.insert(2);
	s1.insert(5);
	s1.insert(3);
	s1.insert(5);
	s1.insert(6);

	cout << "s1" << endl;

	// 遍历方式1：迭代器遍历（注意：*it不可修改）
	// 遍历结果: 去重+有序
	auto it = s1.begin();
	while (it != s1.end())
	{
		//*it1 = 1;//不能修改
		cout << *it << " ";
		it++;
	}
	cout << endl;

// 方式2：初始化列表批量插入
	set<int> s2;
	s2.insert({ 3,1,2,5,3,5,6 });

	cout << "s2" << endl;
	// 遍历方式2：范围for循环
	for (auto& e : s2)
	{
		cout << e << " ";
	}
	cout << endl;

	//若需降序排序，可指定排序仿函数：set<int, greater<int>> s -> 降序排序
	set<int, greater<int>> s3({ 3,1,2,5,3,5,6 }); //列表构造

	cout << "s3" <<endl;

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

int main()
{
	test_set1();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 2.测试set的查找与删除
void test_set2()
{
	set<int> s1;
	s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6

	// 删除最小值 
	s1.erase(s1.begin());//iterator erase (const_iterator position);
	for (auto& e : s1)
	{
		cout << e << " ";
	}
	cout << endl;

	// 直接删除x 
	int x;
	cin >> x;
	int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
	//size_type erase(const value_type & val);
	if (num == 0)
	{
		cout << x << "不存在！" << endl;
	}
	else
	{
		cout << x << "删除成功！" << endl;
	}
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;

	// 直接查找在利用返回值是迭代器删除x 
	set<int> s2({ 3,1,2,5,3,5,6 });
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;

	cin >> x;
	auto pos = s2.find(x);
	if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
	{
		s2.erase(pos);
		//cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
	}
	else
	{
		cout << x << "不存在！" << endl;
	}
	for (auto e : s2)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << endl;

	//// 算法库的查找 O(N) 
	//auto pos1 = find(s2.begin(), s2.end(), x);
	//// set⾃⾝实现的查找 O(logN) 
	//auto pos2 = s2.find(x);

	//// 利用count间接实现快速查找 
	//cin >> x;
	//if (s2.count(x))
	//{
	//	cout << x << "在！" << endl;
	//}
	//else
	//{
	//	cout << x << "不在！" << endl;
	//}

}

int main()
{
	test_set2();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 3.测试set的区间操作
void test_set3()
{
	set<int> s;
	s.insert({ 3,1,2,5,3,5,6,7,9 });

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

	// 需求：删除[3, 8]区间的元素（即 >=3 且 <=8 ）
	// lower_bound(val)：返回第一个 >= val 的迭代器（此处指向3）
	auto it1 = s.lower_bound(3);
	// upper_bound(val)：返回第一个 > val 的迭代器（此处指向9）
	auto it2 = s.upper_bound(8);
	// 按迭代器区间删除：删除[it1, it2)内的元素(左闭右开)
	s.erase(it1, it2); //所以迭代器it2位置不会删除而是删除到左边一个位置结束

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

int main()
{
	test_set3();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 4.测试multiset（支持重复key）
void test_multiset()
{
	multiset<int> s1;
	// 插入重复元素（不会去重）
	s1.insert({ 3,1,2,5,3,5,6,3,3 });

	// 1. 遍历：有序并且保留重复元素
	auto it = s1.begin();
	while (it != s1.end())
	{
		//*it = 1;//不能修改
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 相比set不同的是，x可能会存在多个，find查找中序的第一个
	int x;
	cin >> x;
	auto pos = s1.find(x);
	//打印所有的x
	while (pos != s1.end() && *pos == x)
	{
		cout << *pos << " ";
		pos++;
	}
	cout << endl;

	// 相比set不同的是，count会返回x的实际个数 
	cout << x << ":" << s1.count(x) << "个" << endl;

	//删除：按 key 删除所有匹配元素
	// 相比set不同的是，erase给值时会删除所有的x 
	cout << x << "删除的个数：" << s1.erase(x) << endl;//删掉所有的3，并返回删掉的3的个数
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	test_multiset();
}