Set

set是关联容器。其键值就是实值,实值就是键值,不可以有重复,所以我们不能通过set的迭代器来改变set的元素的值,set拥有和list相同的特性:当对他进行插入和删除操作的时候,操作之前的迭代器依然有效。当然删除了的那个就没效了。set的底层结构是RB-tree,所以是有序的。

stl中特别提供了一种针对set的操作的算法:交集set_intersection,并集set_union,差集set_difference。对称差集set_symeetric_difference,这些算法稍后会讲到。

一:set模板类的声明。

template <
class key
class =Traitsless<key>
class Allocator=allocator<key>
 
>
class set。

其中个参数的意义如下:

key:要放入set里的数据类型,可以是任何类型的数据。

Traits:这是一个仿函数(关于仿函数是什么,我后面的文章会讲到)。提供了具有比较功能的仿函数,来觉得元素在set里的排列的顺序,这是一个可选的参数,默认的是std::less<key>,如果要自己提供这个参数,那么必须要遵循此规则:具有两个参数,返回类型为bool。

Allocator:空间配置器,这个参数是可选的,默认的是std::allocator<key>.

二:set里的基本操作

我们可以通过下面的方法来实例化一个set对

std::set<int> s;那个s这个对象里面存贮的元素是从小到大排序的,(因为用std::less作为比较工具。)

如果要想在s里面插入数据,可以用inset函数(set没用重载[]操作,因为set本生的值和索引是相同的)

s.insert(3);s.insert(5).....

因为set是集合,那么集合本身就要求是唯一性,所以如果要像set里面插入数据和以前的数据有重合,那么插入不成功。

可以通过下面的方法来遍历set里面的元素

1
2
3
4
5
std::set<int>::iterator it = s.begin();
while(it!=s.end())
{
cout<<*it++<<endl;//迭代器依次后移,直到末尾。
}

 

 

如果要查找一个元素用find函数,it = s.find(3);这样it是指向3的那个元素的。可以通过rbegin,rend来逆向遍历

1
2
3
4
5
std::set<int>::reverse_iterator it = s.rbegin();
while(it!=s.rend())
{
  cout<<*it++<<endl;
}

 

 

还有其他的一些操作在这就不一一列出了。

三:set向量的使用实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <string>
#include <set>
#include <algorithm>
#include <iterator>
using namespace std;
/* 联合容器将值与关键字联合在一起,使用关键字来查找值,
* 提供元素的快速访问,插入元素不能指定位置,容器自动处理插入位置
* STL 提供四种联合容器:set、multiset、map、multimap
* set、multiset 存储一种元素,前者关键字不可重复,后者关键字可以重复。
* map、multimap 存储一对元素键与值,前者关键字不可重复,后者关键字可以重复。
*/
int main()
{
const int N = 3;
string s1[N] = {"xp","python","linux"};
string s2[N] = {"python","php","perl"};
set<string> sa(s1, s1 + N);// 声明一个集合sa,元素为数组s1
set<string> sb(s2, s2 + N);// 声明一个集合sb,元素为数组s2
set<string> sc;// 声明一个空集合sc
ostream_iterator<string, char> out (cout, " ");
copy(sa.begin(), sa.end(), out);
cout << "->set sa"<< endl;
copy(sb.begin(), sb.end(), out);
cout << "->set sb"<< endl;
 
set_union(sa.begin(), sa.end(), sb.begin(), sb.end(), out);
cout << "->set_union() 并集" << endl;
set_intersection(sa.begin(), sa.end(), sb.begin(), sb.end(), out);
cout << "->set_intersection() 交集" << endl;
set_difference(sa.begin(), sa.end(), sb.begin(), sb.end(), out);
cout << "->set_difference() 集合的差" << endl;
set_difference(sb.begin(), sb.end(), sa.begin(), sa.end(), out);
cout << "->set_difference() 集合的差" << endl;
 
set_union(sa.begin(), sa.end(), sb.begin(), sb.end(), insert_iterator<set<string> >(sc, sc.begin() ));
sc.insert("delphi");
copy(sc.begin(), sc.end(), out);
cout << "->set sc" << endl;
 
copy(sc.lower_bound("perl"), sc.upper_bound("python"), out);
cout << "->显示集合区间" << endl;
 
return 0;
}

cpp语言中,multiset是<set>库中一个非常有用的类型,它可以看成一个序列,插入一个数,删除一个数都能够在O(logn)的时间内完成,而且他能时刻保证序列中的数是有序的,而且序列中可以存在重复的数。

我们通过一个程序来看如何使用multiset。

#include <string>
#include <iostream>
#include <set>
using namespace std;
void main(){
intx;
scanf("%ld",&x);
multiset<int>h;//建立一个multiset类型,变量名是h,h序列里面存的是int类型,初始h为空
while(x!=0){
h.insert(x);//将x插入h中
scanf("%ld",&x);
}
while(!h.empty()){// 序列非空 h.empty()==true时 表示h已经空了
__typeof(h.begin()) c=h.begin();//c指向h序列中第一个元素的地址,第一个元素是最小的元素
printf("%ld ",*c);//将地址c存的数据输出
h.erase(c);//从h序列中将c指向的元素删除
}
}
对于输入数据32 61 12 2 12 0,该程序的输出是2 12 12 32 61。

我们可以看到,当一个变量h被定义为multiset类型时。所有关于它的操作可以写成如下格式:

h.函数名(形参);

当要在h中插入一个数x时,语法为h.insert(x);当在h中删除指针c指向的元素*c时,语法为h.erase(c)。

注意,如果我们把h.erase(c)写成h.erase(*c),那么该语句就会把h中所有和*c相等的元素都删掉,大家要注意

如果要查找最大的元素并赋值给k,语法是int k=*(h.end()--),注意multiset类型的尾地址存的内容是空的。

如果要想知道当前序列中比k大的元素最小的是多少,那么可以这样 int p=*(h.upper_bound(k)),其中h.upper_bound(k)表示比k大的最小的数的地址。

不光是int类型,multiset还可以存储其他的类型诸如 string类型,结构(struct或class)类型。而我们一般在编程当中遇到的问题经常用到多关键字的类型,即struct或class。例如下面的例子:

struct rec{
int x,y;
};
multiset<rec>h;
以上的代码是没有任何用处的,因为multiset并不知道如何去比较一个自定义的多关键字类型。怎么办呢?我们可以定义multiset里面rec类型变量之间的小于关系的含义(这里以x为第一关键字为例),具体过程如下:

我们定义一个比较类cmp,cmp内部的operator函数的作用是比较rec类型a和b的大小(以x为第一关键字,y为第二关键字):

struct cmp{
bool operator()(const rec&a,const rec&b){
return a.x<b.x||a.x==b.x&&a.y<b.y;
}
};

然后我们将语句"multiset<rec>h;” 改成"multiset<rec,cmp>h;"这样以后,我们就告诉了序列h如何去比较里面的元素(这种方法属于重载运算符,在编程当中经常用到,这里就不详细介绍了)

此时rec以及multiset的定义部分完整代码可参考如下:

struct rec{
int x,y;
};
struct cmp{
bool operator()(const rec&a,const rec&b){
return a.x<b.x||a.x==b.x&&a.y<b.y;
}
};
multiset<rec,cmp>h;
通过以上代码,我们就能建立一个集合h使得该集合能够存储和排序多关键字类型

我们来看一个小应用:求从一个点到另一个点的最短路长度,边都是正权。

正权边的最短路问题可以用dijkstra算法来解决,而优化dijkstra算法可以用heap。这里我们来看如何用multiset实现dijkstra+heap。

以下代码省去了输入输出和图的建立。我们光看求最短路的部分。注意,这里的多关键字类型名称还是rec,multiset集合的名称还是h;多关键字类型rec中,x是第一关键字,y是第二关键字,y代表图中点的编号,而x则代表当前点y与源点的最短距离。

d[0]=0;//源点是0
reca;
a.x=0;//第一关键字x表示距离
a.y=0;//第二关键字y表示点的编号
h.insert(a);//将a插入序列中
while(!h.empty()){//h集合中的元素是否为空
__typeof(h.begin()) c=h.begin();
rect=(*c);//取最小值
h.erase(c);//将最小值删去
for(inti=tail[t.y];i;i=next[i]){
intj=p[i];//枚举和t.y相邻的点
reca;//建立一个结构类变量a
if(d[j]==-1){//d[j]==-1表示j还没有被访问
d[j]=t.x+w[i];//w[i]表示边i的边权
a.x=d[j];
a.y=j;//将j的相关信息保存在rec类型a中
h.insert(a);
}elseif(d[j]>t.x+w[i]){//最短路算法的松弛操作
a.x=d[j];
a.y=j;//将j在序列中的信息存储到a中
c=h.upper_bound(a);//找到序列h中a之后的元素的地址
c--;//地址减一就是a所在的地址
h.erase(c);//删掉a
a.x=t.x+w[i];
d[j]=a.x;//更新最短路的值
h.insert(a);//插入
}
}
}
有了multiset类型,我们就不用再去写平衡树一类的东西了,从而大大降低了编程复杂度

原文地址:https://www.cnblogs.com/hxsyl/p/2677151.html