STL容器之＜set＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

set介绍

1. 关联式容器。
2. 元素是唯一的，即是值又是键。
3. 元素不能直接修改，需要先删除再插入。
4. 支持双向迭代器。
5. 在插入、删除和搜索时间复杂度为log(n)。
6. 可以自动去除重复元素。

头文件

#include 

模块类定义

template<typename _Key, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<_Key> >
    class set{};

_Key：表示存储的键数据类型
_Compare：表示按照键的排序方式。
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

对象构造

/*默认构造函数*/
std::set<int> set1;
/*构造一个set指定排序方式*/
std::set<int> set2(std::greater<int>());
/*拷贝构造函数*/
std::set<int> set3(set1);
/*移动构造函数*/
std::set<int> set4(std::move(set1));
/*初始化列表*/
std::set<int> set5({5,4,3,2,1});
/*初始化列表+排序方式*/
std::set<int> set6({5,4,3,2,1}, std::less<int>());
/*迭代器指定范围构造*/
std::set<int> set7(set6.begin(),set6.end());
/*迭代器指定范围+排序方式*/
std::set<int> set8(set7.begin(), set7.end(), std::less<int>());

初始化

/*初始化列表初始化元素*/
set1 = {1,3,5,4,2};

元素访问

不支持at()函数和下标运算符访问元素

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase()	迭代器或删除元素数量	清除指定位置的一个元素、通过迭代器指定范围内的元素或通过键删除值
emplace()	键值对	插入元素。插入成功时第一个元素是指向新插入元素的迭代器，失败时第一个元素是指向以存在元素的迭代器，第二个元素表示插入结果，true成功，false失败。
emplace_hint()	迭代器	插入成功返回新插入元素的迭代器，插入失败时返回已存在元素的迭代器
insert()	键值对、迭代器、无	1）在指定位置插入1个元素。2）复制通过迭代器指定范围的元素。3）通过初始化列表插入元素。4）直接插入元素。

/*直接构造并插入元素*/
std::pair<std::set<int>::iterator, bool> pair1 = set1.emplace(10);
std::cout << "insert result is "<<std::boolalpha<<pair1.second<<std::endl;
std::cout << "insert value is "<<*(pair1.first)<<std::endl;
/*直接构造元素并插入指定位置，插入元素时可以指定第一个比较元素的位置对应的迭代器，可以减少直接插入排序时数据的比较次数*/
std::set<int>::iterator itr1 = set1.emplace_hint(++set1.begin(),6);
std::cout << "emplace_hint value is "<<*(itr1)<<std::endl;
/*插入元素*/
std::pair<std::set<int>::iterator, bool> pair2 = set1.insert(8);
std::cout << "insert result is "<<std::boolalpha<<pair2.second<<std::endl;
std::cout << "insert value is "<<*(pair2.first)<<std::endl;
/*使用移动函数插入元素，使用移动语句后iValue不要再使用*/
int iValue = 7;
std::pair<std::set<int>::iterator, bool> pair3 = set1.insert(std::move(iValue));
std::cout << "insert result is "<<std::boolalpha<<pair3.second<<std::endl;
std::cout << "insert value is "<<*(pair3.first)<<std::endl;
/*指定位置插入元素*/
std::set<int>::iterator itr2 = set1.insert(++set1.begin(), 12);
std::cout << "insert value is "<<*(itr2)<<std::endl;
/*使用移动函数在指定位置插入元素*/
int iValue1 = 13;
std::set<int>::iterator itr3 = set1.insert(--set1.end(), std::move(iValue1));
std::cout << "insert value is "<<*(itr3)<<std::endl;
/*使用迭代器插入元素*/
set3.insert(++set1.begin(), --set1.end());
/*使用初始化列表插入元素*/
set4.insert({1,2,5,4,8,3});
/*删除指定位置的元素*/
std::set<int>::iterator itr4 = set4.erase(++set4.begin());
std::cout << "erase value is "<<*(itr4)<<std::endl;
/*删除指定范围的元素*/
std::set<int>::iterator itr5 = set4.erase(++set4.begin(), --set4.end());
std::cout << "erase value is " << *(itr5) << std::endl;
/*按值删除元素*/
int iValue3 = set1.erase(1);
std::cout << "erase value count is " << iValue3 << std::endl;
/*清空元素*/
set3.clear();

元素查找

函数	返回值	功能
count()	std::size_t	返回给定键对应元素的数量
find()	迭代器	查找指定键对应元素的位置,未找到则返回end()
lower_bound()	迭代器	查找第一个大于或等于给定键的元素的位置,未找到则返回end()
upper_bound()	迭代器	查找第一个大于给定键的元素的位置，未找到返回end()
equal_range()	迭代器	获取给定键的lower_bound和upper_bound

/*查找指定值的数量*/
std::cout << "count:" << set1.count(5) << std::endl;
/*查找指定值的位置*/
std::set<int>::iterator itr6 = set1.find(4);
std::cout << "find value is " << *(itr6) << std::endl;
/*查找第一个大于等于给定键的元素的位置*/
std::set<int>::iterator itr7 = set1.lower_bound(3);
std::cout << "lower_bound value is "<<*(itr7)<<std::endl;
/*查找第一个大于给定键的元素的位置*/
std::set<int>::iterator itr8 = set1.upper_bound(2);
std::cout << "upper_bound value is "<<*(itr8)<<std::endl;
/*分别返回lower_bound和upper_bound*/
std::pair<std::set<int>::iterator, std::set<int>::iterator> pair4 = set1.equal_range(1);
std::cout << "lower_bound value:"<<*(pair4.first)<<std::endl;
std::cout << "upper_bound value:"<<*(pair4.second)<<std::endl;

容器大小

函数	返回值	功能
size()	std::size_t	获取当前容器中的元素数量
empty()	bool	判断当前容器是否为空，为空返回true，否则返回false
max_size()	std::size_t	返回容器的最大容量

/*判断元素的数量*/
std::cout<<set1.size()<<std::endl;
/*判断容器最大能容纳的元素的数量*/
std::cout<<set1.max_size()<<std::endl;
/*判断容器是否为空*/
std::cout<<set1.empty()<<std::endl;/*判断队列中元素数量*/

迭代器

类型	功能
iterator	正向访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向访问迭代器	返回指向set对象首元素所在位置的迭代器
end()	正向访问迭代器	返回指向set对象末尾元素的下一个位置的迭代器
cbegin()	常量正向访问迭代器	返回指向set对象首元素所在位置的常量迭代器
cend()	常量正向访问迭代器	返回指向set对象末尾元素的下一个位置的迭代器
rbegin()	逆向访问迭代器	返回指向set对象末尾元素位置的迭代器
rend()	逆向访问迭代器	返回指向set对象首元素的前一个位置的迭代器
crbegin()	常量逆向访问迭代器	返回指向set对象末尾元素位置的常量迭代器
crend()	常量逆向访问迭代器	返回指向set对象首元素的前一个位置的常量迭代器

std::set<int> setTest({1,3,2,6,4,5,8,10,9,7});
/*正向随机访问迭代器，并打印输出（1 2 3 4 5 6 7 8 9 10）*/
std::set<int>::iterator itr;
for (itr = setTest.begin(); itr != setTest.end(); itr++)
{
    /* 不允许修改元素值 */
    //*itr += 10; 
    /* 访问元素 */
    std::cout<<*(itr)<<" ";
}
std::cout<<std::endl;
/*常量正向随机访问迭代器，并打印输出（1 2 3 4 5 6 7 8 9 10）*/
std::set<int>::const_iterator cItr;
for (cItr = setTest.cbegin(); cItr != setTest.cend(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout <<*(cItr)<<" ";
}
std::cout<<std::endl;
/*逆向随机访问迭代器，并打印输出（10 9 8 7 6 5 4 3 2 1）*/
std::set<int>::reverse_iterator rItr;
for (rItr= setTest.rbegin(); rItr!= setTest.rend(); rItr++)
{
    /* 不允许修改元素值 */
    //*rItr += 100; 
    /* 访问元素 */
    std::cout <<" " << *(rItr);
}
std::cout<<std::endl;

/*常量逆向随机访问迭代器，并打印输出（10 9 8 7 6 5 4 3 2 1）*/
std::set<int>::const_reverse_iterator crItr;
for (crItr= setTest.crbegin(); crItr!= setTest.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout <<" "<<*crItr;
}
std::cout << std::endl;

其他函数

函数名	返回值	功能
swap()	无	交换两个容器的元素
merge()	无	合并两个集合到一个中

/*交互两个容器元素的值,无返回值*/
std::set<int> setSwap1 = {1,2,3,4,5};
std::set<int> setSwap2 = {6,7,8,9,10};
/*方式1， setSwap1={6,7,8,9,10}, setSwap2={1,2,3,4,5}*/
setSwap1.swap(setSwap2);
/*setSwap1={1,2,3,4,5}, setSwap2={6,7,8,9,10}*/
std::swap(setSwap1,setSwap2);

//元素合并,将setSwap2中的元素合并到setSwap1中，setSwap2中相同的不做操作，不同的会从其中删除，并合并到setSwap1中
setSwap1.merge(setSwap2);
for (auto & item : setSwap1)
{
    std::cout << " "<<item;
}
std::cout << std::endl;