Set容器

时间  2019-11-16
标签 set 容器 繁體版
原文   原文链接

一、Set

（1）定义

set/multiset会根据待定的排序准则，自动将元素排序。二者不一样在于前者不容许元素重复，然后者容许。
ios

set，顾名思义是“集合”的意思，用来存储同一数据类型的数据类型。程序员

在set中元素都是惟一的，并且默认状况下会对元素自动进行升序排列，支持集合的交(set_intersection)，差(set_difference) ，并(set_union)，对称差(set_symmetric_difference) 等一些集合上的操做，若是须要集合中的元素容许重复那么可使用multiset 。
算法

C++ STL 之因此获得普遍的赞誉，也被不少人使用，不仅是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量经常使用数据结构操做。数组

vector封装数组，list封装了链表，map和set封装了二叉树等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的经常使用操做，如：插入、排序、删除、查找等。让用户在STL使用过程当中，并不会感到陌生。
数据结构

应该注意的是set中数元素的值不能直接被改变。
less

（2）底层实现

C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种很是高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。函数

RB树的统计性能要好于通常平衡二叉树，因此被STL选择做为了关联容器的内部结构，插入删除操做时仅仅须要指针操做节点便可完成，不涉及到内存移动和拷贝，因此效率比较高。
性能

（3）模板原型

set模板原型：
spa

template <class Key, class Compare=less<Key>, class Alloc=STL_DEFAULT_ALLOCATOR(Key) >

从原型能够看出，能够看出比较函数对象及内存分配器采用的是默认参数，所以若是未指定，它们将采用系统默认方式。指针

set的标准形式是set<Key, Compare, Alloc>：

（4）特色

1) 不能直接改变元素值，由于那样会打乱本来正确的顺序，要改变元素值必须先删除旧元素，则插入新元素；

2) 不提供直接存取元素的任何操做函数，只能经过迭代器进行间接存取，并且从迭代器角度来看，元素值是常数；

3) 元素比较动做只能用于型别相同的容器(即元素和排序准则必须相同)。

（5）性能分析

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

由于对于关联容器来讲，不须要作内存拷贝和内存移动。set容器内全部元素都是以节点的方式来存储，其节点结构和链表差很少，指向父节点和子节点。结构图可能以下：

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

插入的时候只须要稍作变换，把节点的指针指向新的节点就能够了。删除的时候相似，稍作变换后把指向删除节点的指针指向其余节点便可。这里的一切操做就是指针换来换去，和内存移动没有关系。

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

iterator这里就至关于指向节点的指针，内存没有变，指向内存的指针怎么会失效呢(固然被删除的那个元素自己已经失效了)。

相对于vector来讲，每一次删除和插入，指针都有可能失效，调用push_back在尾部插入也是如此。由于为了保证内部数据的连续存放，iterator指向的那块内存在删除和插入过程当中可能已经被其余内存覆盖或者内存已经被释放了。即便时push_back的时候，容器内部空间可能不够，须要一块新的更大的内存，只有把之前的内存释放，申请新的更大的内存，复制已有的数据元素到新的内存，最后把须要插入的元素放到最后，那么之前的内存指针天然就不可用了。

特别是在和find等算法在一块儿使用的时候，牢记这个原则：不要使用过时的iterator。

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

在set中查找是使用二分查找，也就是说，若是有16个元素，最多须要比较4次就能找到结果，有32个元素，最多比较5次。那么有10000个呢？最多比较的次数为log10000，最多为14次，若是是20000个元素呢？最多不过15次。看见了吧，当数据量增大一倍的时候，搜索次数只不过多了1次，多了1/14的搜索时间而已。这样就能够安心往里面放入元素了。

二、成员函数

（1）构造函数

//建立set对象，共5种方式，提示若是比较函数对象及内存分配器未出现，即表示采用的是系统默认方式
set<int> s1; 
//建立空的set对象，元素类型为int

set<const char*, strLess> s2( strLess); 
//建立空的set对象，元素类型char*，比较函数对象(即排序准则)为自定义strLess

set<int> s3(s1); 
//利用set对象s1,拷贝生成set对象s2

int iArray[] = {13, 32, 19};
set<int> s4(iArray, iArray + 3);
//用迭代区间[&first, &last)所指的元素，建立一个set对象

const char* szArray[] = {"hello", "dog", "bird" };
set<const char*, strLess> s5(szArray, szArray + 3, strLess() );
//用迭代区间[&first, &last)所指的元素，及比较函数对象strLess，建立一个set对象

（2）插入操做

insert(key_value); 
//将key_value插入到set中 ，返回值是pair<set<int>::iterator,bool>，bool标志着插入是否成功，而iterator表明插入的位置，若key_value已经在set中，则iterator表示的key_value在set中的位置。
inset(first,second);
//将定位器first到second之间的元素插入到set中，返回值是void.
insert(&pos, value)
//在pos位置以前插入value，返回新元素位置，但不必定能插入成功

示例：

deque<int> d {1,2,3,4,5};
cout<<"s1.insert(...) : "<<endl;
for (int i = 0; i <5 ; i++)
    s1.insert(i*10);
printSet(s1);
cout<<"s1.insert(20).second = "<<endl;;
if (s1.insert(20).second)
    cout<<"Insert OK!"<<endl;
else
    cout<<"Insert Failed!"<<endl;
cout<<"s1.insert(50).second = "<<endl;
if (s1.insert(50).second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
    cout<<"Insert Failed!"<<endl;
cout<<"pair<set<int>::iterator::iterator, bool> p;/np = s1.insert(60);/nif (p.second):"<<endl;
pair<set<int>::iterator::iterator, bool> p;
p = s1.insert(60);
if (p.second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
   cout<<"Insert Failed!"<<endl;

（3）删除操做

clear();
//删除set容器中的全部的元素

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 中元素是 ：4 5 6 7 9 10
小结：
set中的删除操做是不进行任何的错误检查的，好比定位器的是否合法等等，因此用的时候本身必定要注意。

（4）定位查找

s.begin()
//返回set容器的第一个元素
s.end()
//返回set容器的最后一个元素

c.rbegin()
//返回的值和end()相同
c.rend()
//返回的值和rbegin()相同
c.at(pos)返回索引为pos的位置的元素,会执行边界检查,若是越界抛出out_of_range异常

lower_bound(key_value);
//返回第一个大于等于key_value的定位器
upper_bound(key_value);
//返回最后一个大于等于key_value的定位器

find()；
//返回给定值值得定位器，若是没找到则返回end()

equal_range();
//返回一对定位器，分别表示第一个大于或等于给定关键值的元素和第一个大于给定关键值的元素，
//这个返回值是一个pair类型，若是这一对定位器中哪一个返回失败，就会等于end()的值

count(value);
//返回set对象内元素值为value的元素个数

示例：

#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 中的第一个元素是 ："<<*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;
}

#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
3
4

#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;
}

#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;
}

（5）数据大小

max_size();
//返回set容器可能包含的元素最大个数
size();
//返回当前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 的 size 值为 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
    s.clear();
    if(s.empty())
    {
        cout<<"set 为空 ！！！"<<endl;
    }
    cout<<"set 的 size 值为 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
    return 0;
}
结果：
set的size值为：3
set的maxsize的值为：1073741823
set的size值为：0
set的maxsize的值为：1073741823

小结：
插入3以后虽然插入了一个1，可是咱们发现set中最后一个值仍然是3哈，这就是set 。
还要注意begin() 和 end()函数是不检查set是否为空的，使用前最好使用empty()检验一下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;
}

（6）交换操做

s1.swap(s2)
//交换容器s1,s2;
swap(s1,s2)
//同上。

示例：

set<int> s1,s2;
s1.insert(100);
s2.insert(200);
cout<<"s1.swap(s2) :"<<endl;
s1.swap(s2);

（7）并交差

set_intersection();
//交
set_difference();
//差 
set_union();
//并
set_symmetric_difference();
//对称差

示例：

#include<set>
#include<iterator>
#include<iostream>
using namespace std;
int main()
{
set<int>eg1;
//遍历set，能够发现元素是有序的
set<int>::iterator set_iter=eg1.begin();
cout<<"Set named eg1:"<<endl;
for(;set_iter!=eg1.end();set_iter++) cout<<*set_iter<<" ";
cout<<endl;

set<int>eg2;
for(int i=6;i<15;i++)
eg2.insert(i);
cout<<"Set named eg2:"<<endl;
for(set_iter=eg2.begin();set_iter!=eg2.end();set_iter++)
   cout<<*set_iter<<" ";
cout<<endl;

//得到两个set的并
set<int>eg3;
cout<<"Union:";
set_union(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));//注意第五个参数的形式
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到两个set的交，注意进行集合操做以前接收结果的set要调用clear()函数清空一下
eg3.clear();
set_intersection(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
cout<<"Intersection:";
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到两个set的差
eg3.clear();
set_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
cout<<"Difference:";
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//得到两个set的对称差，也就是假设两个集合分别为A和B那么对称差为AUB-A∩B
eg3.clear();
set_symmetric_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));
copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));
cout<<endl;return 0;
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程