关于C++set容器的使用

最新推荐文章于 2024-07-29 18:41:08 发布

薄层

最新推荐文章于 2024-07-29 18:41:08 发布

阅读量491

点赞数 1

分类专栏： STL函数库文章标签： stl set容器

STL函数库专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文略有修改

1.关于set

C++ STL 之所以得到广泛的赞誉，也被很多人使用，不只是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量常用数据结构操作。vector封装数组，list封装了链表，map和set封装了二叉树等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的常用操作，如：插入、排序、删除、查找等。让用户在STL使用过程中，并不会感到陌生。

关于set，必须说明的是set关联式容器。set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。RB树的统计性能要好于一般平衡二叉树，所以被STL选择作为了关联容器的内部结构。

关于set有下面几个问题：

（1）为何map和set的插入删除效率比用其他序列容器高？

大部分人说，很简单，因为对于关联容器来说，不需要做内存拷贝和内存移动。说对了，确实如此。set容器内所有元素都是以节点的方式来存储，其节点结构和链表差不多，指向父节点和子节点。结构图可能如下：

　　A
　 / \
　 B C
　/ \ / \
D E F G

因此插入的时候只需要稍做变换，把节点的指针指向新的节点就可以了。删除的时候类似，稍做变换后把指向删除节点的指针指向其他节点也OK了。这里的一切操作就是指针换来换去，和内存移动没有关系。

（2）为何每次insert之后，以前保存的iterator不会失效？

iterator这里就相当于指向节点的指针，内存没有变，指向内存的指针怎么会失效呢(当然被删除的那个元素本身已经失效了)。相对于vector来说，每一次删除和插入，指针都有可能失效，调用push_back在尾部插入也是如此。因为为了保证内部数据的连续存放，iterator指向的那块内存在删除和插入过程中可能已经被其他内存覆盖或者内存已经被释放了。即使时push_back的时候，容器内部空间可能不够，需要一块新的更大的内存，只有把以前的内存释放，申请新的更大的内存，复制已有的数据元素到新的内存，最后把需要插入的元素放到最后，那么以前的内存指针自然就不可用了。特别时在和find等算法在一起使用的时候，牢记这个原则：不要使用过期的iterator。

（3）当数据元素增多时，set的插入和搜索速度变化如何？

如果你知道log2的关系你应该就彻底了解这个答案。在set中查找是使用二分查找，也就是说，如果有16个元素，最多需要比较4次就能找到结果，有32个元素，最多比较5次。那么有10000个呢？最多比较的次数为log10000，最多为14次，如果是20000个元素呢？最多不过15次。看见了吧，当数据量增大一倍的时候，搜索次数只不过多了1次，多了1/14的搜索时间而已。你明白这个道理后，就可以安心往里面放入元素了。

2.set中常用的方法

begin() 　　 ,返回set容器的第一个元素

end() 　　　　 ,返回set容器的最后一个元素

clear() 　　 ,删除set容器中的所有的元素

empty() 　　　,判断set容器是否为空

max_size() 　 ,返回set容器可能包含的元素最大个数

size() 　　　　 ,返回当前set容器中的元素个数

rbegin　　　　 ,返回的值和end()相同

rend()　　　　 ,返回的值和rbegin()相同

写一个程序练一练这几个简单操作吧：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   set<int> s;
   s.insert(1);
   s.insert(2);
   s.insert(3);
   s.insert(1);
   cout<<"set 的 size 值为 ："<<s.size()<<endl;
   cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
   cout<<"set 中的第一个元素是 ："<<*s.begin()<<endl;
   cout<<"set 中的最后一个元素是:"<<*s.end()<<endl;
   s.clear();
   if(s.empty())
   {
       cout<<"set 为空 ！！！"<<endl;
   }
   cout<<"set 的 size 值为 ："<<s.size()<<endl;
   cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
   return 0;
} 
    
  

运行结果：

小结：插入3之后虽然插入了一个1，但是我们发现set中最后一个值仍然是3哈，这就是set 。还要注意begin() 和 end()函数是不检查set是否为空的，使用前最好使用empty()检验一下set是否为空.

count() 用来查找set中某个某个键值出现的次数。这个函数在set并不是很实用，因为一个键值在set只可能出现0或1次，这样就变成了判断某一键值是否在set出现过了。

示例代码：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   set<int> s;
   s.insert(1);
   s.insert(2);
   s.insert(3);
   s.insert(1);
   cout<<"set 中 1 出现的次数是 ："<<s.count(1)<<endl;
   cout<<"set 中 4 出现的次数是 ："<<s.count(4)<<endl;
   return 0;
} 
    
  

运行结果：

equal_range() ，返回一对定位器，分别表示第一个大于或等于给定关键值的元素和第一个大于给定关键值的元素，这个返回值是一个pair类型，如果这一对定位器中哪个返回失败，就会等于end()的值。具体这个有什么用途我还没遇到过~~~

示例代码：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   set<int> s;
   set<int>::iterator iter;
   for(int i = 1 ; i <= 5; ++i)
   {
       s.insert(i);
   }
   for(iter = s.begin() ; iter != s.end() ; ++iter)
   {
       cout<<*iter<<" ";
   }
   cout<<endl;
   pair<set<int>::const_iterator,set<int>::const_iterator> pr;
   pr = s.equal_range(3);
   cout<<"第一个大于等于 3 的数是 ："<<*pr.first<<endl;
   cout<<"第一个大于 3的数是 ： "<<*pr.second<<endl;
   return 0;
} 
    
  

运行结果：

erase(iterator) ,删除定位器iterator指向的值

erase(first,second),删除定位器first和second之间的值，删除区间为一个前闭后开的集合

erase(key_value),删除键值key_value的值

看看程序吧：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   set<int> s;
   set<int>::const_iterator iter;
   set<int>::iterator first;
   set<int>::iterator second;
   for(int i = 1 ; i <= 10 ; ++i)
   {
       s.insert(i);
   }
   //第一种删除
   s.erase(s.begin());
   //第二种删除
   first = s.begin();
   second = s.begin();
   second++;
   second++;
   s.erase(first,second);
   //第三种删除
   s.erase(8);
   cout<<"删除后 set 中元素是 ：";
   for(iter = s.begin() ; iter != s.end() ; ++iter)
   {
       cout<<*iter<<" ";
   }
   cout<<endl;
   return 0;
} 
    
  

运行结果：

小结：set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。

find() ，返回给定值值得定位器，如果没找到则返回end()。

示例代码：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   int a[] = {1,2,3};
   set<int> s(a,a+3);
   set<int>::iterator iter;
   if((iter = s.find(2)) != s.end())
   {
       cout<<*iter<<endl;
   }
   return 0;
} 
    
  

insert(key_value); 将key_value插入到set中，返回值是pair<set<int>::iterator,bool>，bool标志着插入是否成功，而iterator代表的是插入数据的值而不是插入的位置，若key_value已经在set中，则插入失败，iterator表示的key_value仍为插入元素的值。

inset(first,second);将定位器first到second之间的元素插入到set中，返回值是void.

示例代码：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   int a[] = {1,2,3};
   set<int> s;
   set<int>::iterator iter;
   s.insert(a,a+3);
   for(iter = s.begin() ; iter != s.end() ; ++iter)
   {
       cout<<*iter<<" ";
   }
   cout<<endl;
   pair<set<int>::iterator,bool> pr;
   pr = s.insert(5);
   if(pr.second)
   {
       cout<<*pr.first<<endl;
   }
   return 0;
} 
    
  

运行结果：

lower_bound(key_value) ，返回第一个大于或等于key_value的定位器

upper_bound(key_value)，返回第一个大于key_value的定位器

其实，equal_range()函数的返回值，就分别是这两个函数的返回值的pair组合。

示例代码：

 
    
  
#include <iostream>
#include <set>

using namespace std;

int main()
{
   set<int> s;
   s.insert(1);
   s.insert(3);
   s.insert(4);
   cout<<*s.lower_bound(2)<<endl;
   cout<<*s.lower_bound(3)<<endl;
   cout<<*s.upper_bound(3)<<endl;
   return 0;
} 
    
  

运行结果：

3.自定义比较函数

当需要用到自己定义的元素时，如结构体，需要自定义比较函数，而基本类型都有已经定义好的比较函数，所以平时用的时候不需要定义比较函数。

 
    
  
 1 struct Info  
 2 {  
 3     int id, val;  
 4     //重载“<”操作符，自定义排序规则  
 5     bool operator < (const Info &a) const  
 6     {   7	   //id相等必定返回false，则会被认为两个元素是相等的，根据id判重 8	   if(id == k.id) return false; 9	   //如果val相等，按照id排序
 10	   if(val == k.val) return id < k.id;	    11        //按val从大到小排列 12	   return val > k.val;                13    }    14 }    15 set<Info> s;    16 ......    17 set<Info>::iterator it;

为甚么要重载<运算符呢？能不能重载"<="或者">="运算符？答案是不可以。几乎所有的方法或容器都需要排序来满足数学意义上的标准严格弱序化，否则这些方法或容器的行为将不可预知。假设f(x,y)是一个比较函数。如果该函数满足如下条件则它是严格弱序化的。

　　　 1.f(x,x) = false;

　　　　2. if f(x,y) then !f(y,x)

　　　　3.if f(x,y) and f(y,z) then f(x,z)

　　　　4. if !f(x,y)&&!f(y,x) then x==y; if x==y and y==z then x==z;

看上去有点晕乎，不过不用担心，只要你的比较方法能够满足对相等元素永远返回false（记住一个准则：永远让比较函数对相同元素返回false），那你的方法就满足要求了。

　　　　其实，set容器在判定已有元素a和新插入元素b是否相等时，是这么做的：1）将a作为左操作数，b作为有操作数，调用比较函数，并返回比较值 2）将b作为左操作数，a作为有操作数，再调用一次比较函数，并返回比较值。如果1、2两步的返回值都是false，则认为a、b是相等的，则b不会被插入set容器中；如果1、2两步的返回值都是true，则可能发生未知行为，因此，记住一个准则：永远让比较函数对相同元素返回false。

4.。。。

本人很多时候用到set都是在做算法题，因此加一个输出set所有元素，两元素之间有空格，末尾不允许有空格的小技巧——很笨拙，

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <set>
 4 using namespace std;
 5 int main(){
 6 	int count;
 7 	set<int> se;
 8	se.insert(5);
 9	se.insert(7);
10	se.insert(3);
11	se.insert(2);
12	set<int>::iterator it;
13	count = se.size();		//简单地用一个count计数
14	for(it = se.begin(); it != se.end(); ++it){
15		printf("%d%c", *it, it==se.end()?'\n':' ');
16	}
17	return 0;
18 }