STL-Set集合

STL-Set集合

set 集合 unordered_set 无序集合

set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。 set不允许两个元素有相同的键值。

不允许出现相同的两个
set 根据元素的值，系统自动排序

底层原理 hash表

导入

#incude<set>
#incdue<unordered_set>

构造

常见的创建 set 容器的方法，大致有以下 5 种。

std::set<std::string> myset;   //默认构造函数

std::set<std::string> copyset(myset);  //复制构造
//等同于
//std::set<std::string> copyset = myset


set<string> mysets{"python","go","java"};  //构造初始化
std::set<std::string> myset{"python","go","java"};  //构造初始化


std::set<std::string> copyset(++myset.begin(), myset.end());   // 复制初始化


set<string, std::greater<string>> words {"one", "two", "three"};

插入删除

添加元素

//插入数据
set<string>  str_set;
str_set.insert("china");
str_set.insert("us");


set<string, greater<string>> words {"one", "two", "three"};

// 插入单个元素会返回一个 pair<iterator，bool> 对象。
auto pr1 = words.insert("four");
auto pr2 = words.insert ("two") ;

//插入单个元素和一个标识，会返回一个迭代器。
auto iter3 = words.insert(pr.first, "seven");

//插入一段元素或一个初始化列表就不会有返回值。
words.insert ({ "five","six"}) ;

//当 insert() 的参数是初始化列表时，会用列表中的字符串创建 string 对象
string wrds[] {"eight", "nine", "ten"};
words.insert(std::begin(wrds) , std::end(wrds));

删除元素

成员函数 clear() 会删除 set 的所有元素。成员函数 erase() 会删除迭代器指定位置的元素或与对象匹配的元素

//删除 set 容器中值为 val 的元素
size_type erase (const value_type& val);
//删除 position 迭代器指向的元素
iterator  erase (const_iterator position);
//删除 [first,last) 区间内的所有元素
iterator  erase (const_iterator first, const_iterator last);

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化 set 容器
    std::set<int>myset{1,2,3,4,5};
    cout << "myset size = " << myset.size() << endl;
   
    //1. erase() 方法
    int num = myset.erase(2); //删除元素 2，myset={1,3,4,5}
    cout << "1. myset size = " << myset.size() << endl;
    cout << "num = " << num << endl;
    
    //2. erase() 方法
    set<int>::iterator iter = myset.erase(myset.begin()); //删除元素 1，myset={3,4,5}
    cout << "2. myset size = " << myset.size() << endl;
    cout << "iter->" << *iter << endl;
    
    //3. erase() 方法
    set<int>::iterator iter2 = myset.erase(myset.begin(), --myset.end());//删除元素 3,4，myset={5}
    cout << "3. myset size = " << myset.size() << endl;
    cout << "iter2->" << *iter2 << endl;
    return 0;
}

//myset size = 5
//1. myset size = 4
//num = 1
//2. myset size = 3
//iter->3
//3. myset size = 1
//iter2->5

删除 set 容器中存储的所有元素

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化 set 容器
    std::set<int>myset{1,2,3,4,5};
    cout << "1. myset size = " << myset.size() << endl;
    //清空 myset 容器
    myset.clear();
    cout << "2. myset size = " << myset.size() << endl;
    return 0;

查找元素

find()函数用于查找具有给定值 val 的元素。如果找到元素，则返回指向该元素的迭代器

否则返回指向集合末尾的迭代器即set :: end()。

#include <iostream>
#include <set>

using namespace std;

int main(void) {
   set<int> m = {100,200,300,400};

   auto it = m.find(300);

   cout << "iter ->  " << *it << endl;

   return 0;
}
//iter ->  300

//打印输出
for(std::set<int>::iterator iter=chars.begin();iter!=chars.end();++iter){
    cout<< *iter<< endl;
    }


set<string> str_set;
str_set.insert("123")
set<string>::iterator  it= str_set.find("123"); 
cout<< *it<< endl;   //如果输出的是 123 则说明找到

//或者     
//返回一个迭代器  iterator  
if(str_set.find("123")!=str_end()){
    cout<<"find 123" <<endl;
}else {
    cout<<"not find 123"<<endl;
}
    
//是否在set中
//str_set.count();

遍历元素

#include <iostream>
#include <set>
#include <string>
using namespace std;

int main()
{
    std::set<int> numbers{2, 4, 6, 8, 10, 12, 14};


    for (auto  it= numbers.begin(); it != numbers.end(); i++)
        cout << *it << " "; // 注意指针运算符

    numbers.clear();

    return 0;
}

成员方法

成员方法	功能
begin()	返回指向容器中第一个（注意，是已排好序的第一个）元素的双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
end()	返回指向容器最后一个元素（注意，是已排好序的最后一个）所在位置后一个位置的双向迭代器，通常和 begin() 结合使用。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
rbegin()	返回指向最后一个（注意，是已排好序的最后一个）元素的反向双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
rend()	返回指向第一个（注意，是已排好序的第一个）元素所在位置前一个位置的反向双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
cbegin()	和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
cend()	和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crbegin()	和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crend()	和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
find(val)	在 set 容器中查找值为 val 的元素，如果成功找到，则返回指向该元素的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(val)	返回一个指向当前 set 容器中第一个大于或等于 val 的元素的双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
upper_bound(val)	返回一个指向当前 set 容器中第一个大于 val 的元素的迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
equal_range(val)	该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的值为 val 的元素（set 容器中各个元素是唯一的，因此该范围最多包含一个元素）。
empty()	若容器为空，则返回 true；否则 false。
size()	返回当前 set 容器中存有元素的个数。
max_size()	返回 set 容器所能容纳元素的最大个数，不同的操作系统，其返回值亦不相同。
insert()	向 set 容器中插入元素。
erase()	删除 set 容器中存储的元素。
swap()	交换 2 个 set 容器中存储的所有元素。这意味着，操作的 2 个 set 容器的类型必须相同。
clear()	清空 set 容器中所有的元素，即令 set 容器的 size() 为 0。
emplace()	在当前 set 容器中的指定位置直接构造新元素。其效果和 insert() 一样，但效率更高。
emplace_hint()	在本质上和 emplace() 在 set 容器中构造新元素的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示新元素生成位置的迭代器，并作为该方法的第一个参数。
count(val)	在当前 set 容器中，查找值为 val 的元素的个数，并返回。注意，由于 set 容器中各元素的值是唯一的，因此该函数的返回值最大为 1。

multiset

multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。

set<T> st;//set默认构造函数： 
mulitset<T> mst; //multiset默认构造函数: 
set(const set &st);//拷贝构造函数

#include <iostream>
#include <set>
using namespace std;

void printSetInt(multiset<int> &mset)
{
  
   for (auto  it = mset.begin(); it != mset.end(); it++)
   {
      cout << *it << " ";
   }
   cout << endl;
}
void test()
{
   multiset<int> s;
   s.insert(10);
   s.insert(10);
   s.insert(10);
   printSetInt(s);
}
int main(int argc, char *argv[])
{
   test();
   return 0;
}
10 10 10

unordered_set

unordered_set 和set 区别

底层数据结构： std::set 通常基于树结构（例如红黑树）实现，而 std::unordered_set 则基于哈希表实现。

元素顺序：由于 std::set 是基于树实现的，所以它的元素是按顺序存储的，这意味着你可以使用迭代器来遍历元素并期望它们以某种顺序出现。相反，std::unordered_set 不保证元素的顺序，也就是说，你无法期望使用迭代器遍历时元素的顺序保持不变。

查找和插入操作的效率：由于 std::set 是基于树结构实现的，所以查找和插入操作的平均时间复杂度为 O(log n)。而 std::unordered_set 使用哈希表，所以查找和插入操作的平均时间复杂度为 O(1)，但是这个 O(1) 性能依赖于哈希函数的工作方式以及哈希表的大小。

空间消耗：由于哈希表的使用，std::unordered_set 在空间上的消耗通常会比 std::set 大一些。

#include <iostream>  
#include <unordered_set>  
  
int main() {  
    std::unordered_set<int> us; // 声明一个整数无序集合  
  
    // 插入元素  
    us.insert(1);  
    us.insert(2);  
    us.insert(3);  
  
    // 查找元素  
    if (us.find(2) != us.end()) {  
        std::cout << "Element 2 is in the set" << std::endl;  
    }  
  
    // 删除元素  
    us.erase(2);  
  
    // 遍历元素  
    for (int x : us) {  
        std::cout << x << " ";  
    }  
    std::cout << std::endl;  
  
    return 0;  
}