STL常用容器—set容器
- 1. set容器相关概念
- 2. 初始化容器
- 3. set容器插入和删除
- 4. set容器大小和交换
- 5. set容器的查找和统计
- 6. set、multiset、unordered_set三者的区别
- 7. pair对组的创建
- 8. set容器的排序
参考博文：STL常用容器——set容器的使用
1. set容器相关概念
set容器特点:
- 所有元素插入时候会被自动排序
- set容器不允许插入重复值
- 出入数据 只能用insert
set容器本质:
set/multiset属于关联式容器，底层结构是用二叉树实现
2. 初始化容器
定义与初始化
默认构造:
set<int> s1;
构造容器并初始化:
set<int> s2{1,2,3,5,4};
拷贝构造:
set<int> s3(s2);
//等同于赋值
set<int> s3 = s2;
插入数据
set容器插入数据只能使用insert
set<int> s2{1,2,3,5,4};
s2.insert(15); //s2容器中插入数据15
s2.insert(10); //s2容器中插入数据10
s2.insert(15); //s2容器中插入数据15
show_set(s2);
若插入已存在的数据，插入失败但不报错，因为set容器数据不能重复
输出结果：
1 2 3 5 4 5 10 15
打印输出
注： 打印输出容器函数，后续打印没有特别说明均使用的是该函数
void show_set(set<int> &s)
{
for(set<int>::iterator it = s.begin(); it != s.end();it++)
cout << *it << " ";
cout << endl;
}
3. set容器插入和删除
| 方法 | 功能 |
|---|---|
| ☆ insert( elem ) | 在容器中插入元素，常用 |
| clear( ) | 清空容器（删除所有元素） |
| erase( pos ) | 删除pos迭代器所指的元素，返回下一个元素的迭代器 |
| erase(beg, end) | 删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器 |
| ☆ erase(elem) | 删除容器中值为elem的元素 |
void test03()
{
set<int> s1{2,5,3,8,0,3,6}; //构造容器并初始化
//容器实际排序 0 2 3 5 6 8
//删除某个元素
s1.erase(100); //若该元素不存在，则容器不变
//删除某个迭代位置 删除第一个
s1.erase(s1.begin()); // 2 3 5 6 8
//删除最后一个
s1.erase(--s1.end());
show_set(s1); // 2 3 5 6
//删除某个迭代区间
s1.erase(++s1.begin(), --s1.end());
show_set(s1); // 2 6
s1.clear(); //清空容器
}
4. set容器大小和交换
| 方法 | 功能 |
|---|---|
| size(); | 返回容器中元素的数目 |
| empty( ); | 判断容器是否为空 |
| swap( st ); | 交换两个集合容器 |
void test04()
{
set<int> s1{10,20,45,30}; //默认构造
set<int> s2{1,2,3,5,4}; //构造容器并初始化
//判断容器是否为空
if(!s1.empty()){
//若不为空 则输出容器的大小
cout << "s1.size= " << s1.size() << endl;
cout << "s1: ";
show_set(s1); //打印容器
}
if(!s2.empty()){
cout << "s2.size= " << s2.size() << endl;
cout << "s2: ";
show_set(s2);
}
//交换两个容器 并输出交换后的结果
cout << "swap(s1,s2)" << endl;
cout << "s1: ";
show_set(s1);
cout << "s2: ";
show_set(s2);
}
输出结果：
s1.size= 4
s1: 10 20 30 45
s2.size= 5
s2: 1 2 3 4 5
swap(s1,s2)
s1: 10 20 30 45
s2: 1 2 3 4 5
注： set容器不支持resize方法。
5. set容器的查找和统计
| 方法 | 功能 |
|---|---|
| find(key); | 查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end()，常用 判断元素是否出现等 |
| count(key); | 统计key的元素个数 |
注：
（1）对于set容器而言，元素的值是不能重复的，因此count返回的值为1或0，key元素存在则返回1，不存在则返回0。
（2）find函数返回的是迭代器
void test()
{
set<int> s1{2,5,3,8,0,3,6}; //构造容器并初始化
//set容器实际排序 0 2 3 5 6 8
//查找
set<int>::iterator pos = s1.find(3);
if(pos != s1.end())
cout << "找到该元素：" << *pos << endl;
else
cout << "未找到该元素" << endl;
//统计个数
int num = s1.count(3);
if(num == 1)
cout << "存在该元素 个数为1" << endl;
else
cout << "不存在该元素 " << endl;
}
输出结果：
找到该元素：3
存在该元素 个数为1
6. set、multiset、unordered_set三者的区别
| 集合 | 是否有序 | 数值知否可重复 | 底层实现 |
|---|---|---|---|
| std::set | 有序 | 不可重复 | 红黑树 |
| std::multiset | 有序 | 可重复 | 红黑树 |
| std::unordered_set | 无序 | 不可重复 | 哈希表 |
（1）在哈希表数据结构算法中，若输出的结果是去重的， 同时可以不考虑输出结果的顺序，则优先使用unordered_set容器，底层为哈希表，相对数的查找效率更高
（2）set和multiset 在头文件 #include <set> 中，而unordered_set 在头文件 #include <unordered_set> 中
set容器插入数据
set.insert函数原型：
_Pairib insert(value_type&& _Val)
_Pairib定义：
using _Pairib = pair<iterator, bool>
本质上是pair，称为对组，即成对出现的一组数据，有两个数据成对出现，第一个数据是迭代器，第二个数据为bool类型的数据，定义一个对组用来接收insert的返回值
pair<set<int>::iterator, bool> ret;
获取set容器的insert插入结果
void test06()
{
set<int> s1{2,5};
pair<set<int>::iterator, bool> ret = s1.insert(3);
if(ret.second == true) //通过ret.second 读取对组里面的第二个值
cout << "第一次插入成功"<< endl;
else
cout << "第一次插入失败"<< endl;
ret = s1.insert(3);
if(ret.second == true)
cout << "第二次插入成功"<< endl;
else
cout << "第二次插入失败"<< endl;
}
输出结果：
第一次插入成功
第二次插入失败
multiset容器插入数据
ms.insert函数原型：
iterator insert(value_type&& _Val)
multiset容器insert插入函数返回的是一个迭代器
multiset<int> ms{2,5};
ms.insert(10);
ms.insert(10);
ms.insert(10);
for(multiset<int>::iterator it=ms.begin(); it != ms.end(); it++)
cout << *it << " ";
cout << endl;
输出结果：
2 5 10 10 10
因此如果不允许插入重复数据可以利用set，如果需要插入重复数据利用multiset
7. pair对组的创建
如果一个函数想要返回两个数据，可以考虑使用对组返回数据，两个数据分别用pair的两个公有函数 first 和 second 访问。
对组的创建：
- pair(); 默认构造函数
- pair<type,type> p( value1,value2); 直接使用 2 个元素初始化成 pair 对象
- pair(const pair<U,V>& pr) 拷贝（复制）构造函数
- pair<type,type> p = make_pair(value1,value2);
有参构造：
pair<string, int> stu1("zhangsan", 22);
利用make_pair函数：
pair<string, int> stu2 = make_pair("lisi", 20);
数据赋值与读取：
void test07()
{
pair<string, int> stu; //默认构造函数
pair<string, int> stu1("zhangsan", 22); //有参构造
pair<string, int> stu2 = make_pair("lisi", 20); //使用make_pair函数
pair<string, int> stu3(stu2); //拷贝（复制）构造函数
stu.first = "lihua";
stu.second = 18; //对stu对组数据赋值
stu3.first = "wangwu"; //修改stu3第一个数据，第二个数据拷贝的stu2
//读取对组数据
cout << "stu name= " << stu.first << "\tage= " << stu.second << endl;
cout << "stu1 name= " << stu1.first << "\tage= " << stu1.second << endl;
cout << "stu2 name= " << stu2.first << "\t\tage= " << stu2.second << endl;
cout << "stu3 name= " << stu3.first << "\tage= " << stu3.second << endl;
}
输出结果：
8. set容器的排序
set容器默认排序规则为从小到大，但可通过仿函数，改变排序规则。在这里仿函数不过多讲解，只进行应用，仿函数相当于重载了函数调用运算符（）。
set容器存放内置数据类型
一旦对set容器插入数据后，容器内顺序已经固定，因此要改变容器的排序顺序，应**先设定排序顺序，再插入数据**。在设置排序规则时，需要使用仿函数，因此先定义从大到小的排序仿函数。定义仿函数
//set容器的排序
//从大到小的排序仿函数
class Myset
{
public:
bool operator()(int v1, int v2) //第一个()表重载的符号，第二个()是函数参数列表的括号
{
return v1>v2;
}
};
定义从大到小排序的s2容器
//指定排序规则为从大到小 对s2容器起作用
set<int, Myset> s2{2,5,3,8,0,3,6}; //仿函数本质是个类型
迭代输出，注意s2的类型为set<int, Myset>，因此s2的迭代器类型也应该为set<int, Myset>
//遍历s2容器
//s2 容器类型为set<int, Myset>, 所以迭代器类型也为set<int, Myset>
for(set<int, Myset>::iterator it = s2.begin(); it != s2.end();it++)
cout << *it << " ";
cout << endl;
完整测试代码如下：
//set容器的排序
//从大到小的排序仿函数
class Myset
{
public:
bool operator()(int v1, int v2) //第一个()表重载的符号，第二个()是函数参数列表的括号
{
return v1>v2;
}
};
void test()
{
set<int> s1{2,5,3,8,0,3,6}; //构造容器并初始化
//set容器实际排序 0 2 3 5 6 8
cout << "---------原s1容器为: ----------" << endl;
show_set(s1);
//现在s1已经确定了排序规则，无法再进行更改
//因此要在容器插入数据之前就设置排序规则
//指定排序规则为从大到小 对s2容器起作用
set<int, Myset> s2{2,5,3,8,0,3,6}; //仿函数本质是个类型
//遍历s2容器
//s2 容器类型为set<int, Myset>, 所以迭代器类型也为set<int, Myset>
cout << "---------新s2容器为: ----------" << endl;
for(set<int, Myset>::iterator it = s2.begin(); it != s2.end();it++)
cout << *it << " ";
cout << endl;
}
输出结果：
set容器存放自定义数据类型
定义自定义数据类型Student
//自定义数据类型 Student
class Student{
public:
Student(); //无参构造
Student(string name, int age, int score, char sex); //有参构造
string name;
int age;
int score;
char sex;
};
Student::Student(string name, int age, int score, char sex)
{
this->name = name;
this->age = age;
this->score = score;
this->sex = sex;
}
定义仿函数 根据学生成绩降序排序
//根据学生成绩从高到低排序的仿函数
class compareStudent
{
public:
bool operator()(const Student &stu1, const Student &stu2) //第一个()表重载的符号，第二个()是函数参数列表的括号
{
return stu1.score > stu2.score;
}
};
测试案例
void test()
{
//自定义数据 都要先指定排序规则 编译器不清楚如何排
set<Student, compareStudent> s1;
//实例化对象
Student stu1("zhangsan", 22, 80, 'm');
Student stu2("lisi", 20, 70, 'm');
Student stu3("wangwu", 21, 95, 'm');
Student stu4("chenliu", 22, 86, 'w');
//自定义数据存入set容器
s1.insert(stu1);
s1.insert(stu2);
s1.insert(stu3);
s1.insert(stu4);
//通过迭代器遍历数据
for(set<Student, compareStudent>::iterator it = s1.begin(); it != s1.end(); it++)
cout << "姓名: " << it->name << "\t年龄: " << it->age << "\t成绩: " << it->score << endl;
}
注： set容器插入自定义类型的数据，必须编写仿函数来确定排序的关键词和规则。
输出结果：
![SCI 1区论文：Segment anything in medical images（MedSAM）[文献阅读]](https://img-blog.csdnimg.cn/img_convert/4af6fd05e52fcf8a6dc046d3e327b3e3.png#pic_center)
