STL之Set:Set的基本用法

转载自https://blog.csdn.net/ac_hexin/article/details/52042562

        平衡二叉检索树的检索使用中序遍历算法,检索效率高于vector、deque、和list的容器。另外,采用中序遍历算法可将键值由小到大遍历出来,所以,可以理解为平衡二叉检索树在插入元素时,就会自动将元素按键值从小到大的顺序排列。

Set容器和其他容器差不多,无非就是相同的值不存,存进去自动排序好了。

        构造set集合的主要目的是为了快速检索,使用set前,需要在程序头文件中包含声明“#include<set>”。

1.创建set集合对象

           创建set对象时,需要指定元素的类型,这一点和其他容器一样。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. int main()
  5. {
  6. set< int> s;
  7. return 0;
  8. }
2.元素的插入与中序遍历

        采用inset()方法把元素插入到集合中,插入规则在默认的比较规则下,是按元素值从小到大插入,如果自己指定了比较规则函数,则按自定义比较规则函数插入。使用前向迭代器对集合中序遍历,结果正好是元素排序后的结果。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. int main()
  5. {
  6. set< int> s;
  7. s.insert( 5); //第一次插入5,可以插入
  8. s.insert( 1);
  9. s.insert( 6);
  10. s.insert( 3);
  11. s.insert( 5); //第二次插入5,重复元素,不会插入
  12. set< int>::iterator it; //定义前向迭代器
  13. //中序遍历集合中的所有元素
  14. for(it = s.begin(); it != s.end(); it++)
  15. {
  16. cout << *it << " ";
  17. }
  18. cout << endl;
  19. return 0;
  20. }
  21. //运行结果:1 3 5 6
3.元素的方向遍历

        使用反向迭代器reverse_iterator可以反向遍历集合,输出的结果正好是集合元素的反向排序结果。它需要用到rbegin()和rend()两个方法,它们分别给出了反向遍历的开始位置和结束位置。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. int main()
  5. {
  6. set< int> s;
  7. s.insert( 5); //第一次插入5,可以插入
  8. s.insert( 1);
  9. s.insert( 6);
  10. s.insert( 3);
  11. s.insert( 5); //第二次插入5,重复元素,不会插入
  12. set< int>::reverse_iterator rit; //定义反向迭代器
  13. //反向遍历集合中的所有元素
  14. for(rit = s.rbegin(); rit != s.rend(); rit++)
  15. {
  16. cout << *rit << " ";
  17. }
  18. cout << endl;
  19. return 0;
  20. }
  21. //运行结果:6 5 3 1
4.元素的删除

        与插入元素的处理一样,集合具有高效的删除处理功能,并自动重新调整内部的红黑树的平衡。删除的对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素和清空集合。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. int main()
  5. {
  6. set< int> s;
  7. s.insert( 5); //第一次插入5,可以插入
  8. s.insert( 1);
  9. s.insert( 6);
  10. s.insert( 3);
  11. s.insert( 5); //第二次插入5,重复元素,不会插入
  12. s.erase( 6); //删除键值为6的元素
  13. set< int>::reverse_iterator rit; //定义反向迭代器
  14. //反向遍历集合中的所有元素
  15. for(rit = s.rbegin(); rit != s.rend(); rit++)
  16. {
  17. cout << *rit << " ";
  18. }
  19. cout << endl;
  20. set< int>::iterator it;
  21. it = s.begin();
  22. for( int i = 0; i < 2; i++)
  23. it = s.erase(it);
  24. for(it = s.begin(); it != s.end(); it++)
  25. cout << *it << " ";
  26. cout << endl;
  27. s.clear();
  28. cout << s.size() << endl;
  29. return 0;
  30. }
  31. /*
  32. 运行结果:
  33. 5 3 1
  34. 5
  35. 0
  36. */
5.元素的检索

          使用find()方法对集合进行检索,如果找到查找的的键值,则返回该键值的迭代器位置;否则,返回集合最后一个元素后面的一个位置,即end()。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. int main()
  5. {
  6. set< int> s;
  7. s.insert( 5); //第一次插入5,可以插入
  8. s.insert( 1);
  9. s.insert( 6);
  10. s.insert( 3);
  11. s.insert( 5); //第二次插入5,重复元素,不会插入
  12. set< int>::iterator it;
  13. it = s.find( 6); //查找键值为6的元素
  14. if(it != s.end())
  15. cout << *it << endl;
  16. else
  17. cout << "not find it" << endl;
  18. it = s.find( 20);
  19. if(it != s.end())
  20. cout << *it << endl;
  21. else
  22. cout << "not find it" << endl;
  23. return 0;
  24. }
  25. /*
  26. 运行结果:
  27. 6
  28. not find it
  29. */

下面这种方法也能判断一个数是否在集合中:


        
        
  1. #include <cstdio>
  2. #include <set>
  3. using namespace std;
  4. int main() {
  5. set < int> s;
  6. int a;
  7. for( int i = 0; i < 10; i++)
  8. s.insert(i);
  9. for( int i = 0; i < 5; i++) {
  10. scanf( "%d", &a);
  11. if(!s.count(a)) //不存在
  12. printf( "does not exist\n");
  13. else
  14. printf( "exist\n");
  15. }
  16. return 0;
  17. }

6.自定义比较函数

         使用insert将元素插入到集合中去的时候,集合会根据设定的比较函数奖该元素放到该放的节点上去。在定义集合的时候,如果没有指定比较函数,那么采用默认的比较函数,即按键值从小到大的顺序插入元素。但在很多情况下,需要自己编写比较函数。

编写比较函数有两种方法。

(1)如果元素不是结构体,那么可以编写比较函数。下面的程序比较规则为按键值从大到小的顺序插入到集合中。


        
        
  1. #include<iostream>
  2. #include<set>
  3. using namespace std;
  4. struct mycomp
  5. { //自定义比较函数,重载“()”操作符
  6. bool operator() (const int &a, const int &b)
  7. {
  8. if(a != b)
  9. return a > b;
  10. else
  11. return a > b;
  12. }
  13. };
  14. int main()
  15. {
  16. set< int, mycomp> s; //采用比较函数mycomp
  17. s.insert( 5); //第一次插入5,可以插入
  18. s.insert( 1);
  19. s.insert( 6);
  20. s.insert( 3);
  21. s.insert( 5); //第二次插入5,重复元素,不会插入
  22. set< int,mycomp>::iterator it;
  23. for(it = s.begin(); it != s.end(); it++)
  24. cout << *it << " ";
  25. cout << endl;
  26. return 0;
  27. }
  28. /*
  29. 运行结果:6 5 3 1
  30. */
(2)如果元素是结构体,那么可以直接把比较函数写在结构体内。


        
        
  1. #include<iostream>
  2. #include<set>
  3. #include<string>
  4. using namespace std;
  5. struct Info
  6. {
  7. string name;
  8. double score;
  9. bool operator < ( const Info &a) const // 重载“<”操作符,自定义排序规则
  10. {
  11. //按score由大到小排序。如果要由小到大排序,使用“>”即可。
  12. return a.score < score;
  13. }
  14. };
  15. int main()
  16. {
  17. set<Info> s;
  18. Info info;
  19. //插入三个元素
  20. info.name = "Jack";
  21. info.score = 80;
  22. s.insert(info);
  23. info.name = "Tom";
  24. info.score = 99;
  25. s.insert(info);
  26. info.name = "Steaven";
  27. info.score = 60;
  28. s.insert(info);
  29. set<Info>::iterator it;
  30. for(it = s.begin(); it != s.end(); it++)
  31. cout << (*it).name << " : " << (*it).score << endl;
  32. return 0;
  33. }
  34. /*
  35. 运行结果:
  36. Tom : 99
  37. Jack : 80
  38. Steaven : 60
  39. */


Set常用函数:跟其他容器的函数差不多,好像都通用

c++ stl容器set成员函数:begin()–返回指向第一个元素的迭代器

c++ stl容器set成员函数:clear()–清除所有元素

c++ stl容器set成员函数:count()–返回某个值元素的个数

c++ stl容器set成员函数:empty()–如果集合为空,返回true

c++ stl容器set成员函数:end()–返回指向最后一个元素的迭代器

c++ stl容器set成员函数:equal_range()–返回集合中与给定值相等的上下限的两个迭代器

c++ stl容器set成员函数:erase()–删除集合中的元素

c++ stl容器set成员函数:find()–返回一个指向被查找到元素的迭代器

c++ stl容器set成员函数:get_allocator()–返回集合的分配器

c++ stl容器set成员函数:insert()–在集合中插入元素

c++ stl容器set成员函数:lower_bound()–返回指向大于(或等于)某值的第一个元素的迭代器

c++ stl容器set成员函数:key_comp()–返回一个用于元素间值比较的函数

c++ stl容器set成员函数:max_size()–返回集合能容纳的元素的最大限值

c++ stl容器set成员函数:rbegin()–返回指向集合中最后一个元素的反向迭代器

c++ stl容器set成员函数:rend()–返回指向集合中第一个元素的反向迭代器

c++ stl容器set成员函数:size()–集合中元素的数目

c++ stl容器set成员函数:swap()–交换两个集合变量

c++ stl容器set成员函数:upper_bound()–返回大于某个值元素的迭代器

c++ stl容器set成员函数:value_comp()–返回一个用于比较元素间的值的函数

        </div>
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值