简介

set是一种随机存储的关联式容器，其关键词（key）和元素（value）是同一个值。set之中所有元素互不相同。set是通过二叉查找树来实现的。

创建

创建一个空的set

  1: set<int> s0 ;

创建一个带大于比较器的set, 默认是小于比较器less<int>

  1: set<int, greater<int>> s1 ;

用数组初始化一个set

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s2(a, a + 3) ;

用拷贝构造函数初始化set

  1: set<int> s1 ;

  2: set<int> s2(s1) ;

区间初始化

  1: set<int> s1 ;

  2: set<int> s2(s1.begin(), s1.end()) ;

自定义比较函数

以类为比较器

  1: struct classcmp

  2: {

  3:   bool operator()(const int& lhs, const int& rhs)

  4:   {

  5:     return lhs < rhs ;

  6:   }

  7: };

  8: 

  9: int main(void)

 10: {

 11:   set<int, classcmp> s5 ;

 12: 

 13:   system("pause") ;

 14:   return 0 ;

 15: }

以函数指针为比较器

  1: bool fncmp(int lhs, int rhs)

  2: {

  3:   return lhs < rhs ;

  4: }

  5: 

  6: int main(void)

  7: {

  8:   bool(*fn_pt)(int, int) = fncmp ;

  9:   set<int, bool(*)(int, int)> s1(fn_pt) ;

 10: 

 11:   system("pause") ;

 12:   return 0 ;

 13: }

遍历

正向遍历

使用while

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s(a, a + 3) ;

  3: 

  4: set<int>::const_iterator itor ;

  5: itor = s.begin() ;

  6: 

  7: while (itor != s.end())

  8: {

  9:   cout << *itor << endl ;

 10:   ++itor ;

 11: }

使用for

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s(a, a + 3) ;

  3: 

  4: set<int>::const_iterator itor ;

  5: for (itor = s.begin(); itor != s.end(); ++itor)

  6: {

  7:   cout << *itor << endl ;

  8: }

反向遍历

使用while

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s(a, a + 3) ;

  3: 

  4: set<int>::const_reverse_iterator ritor ;

  5: ritor = s.rbegin() ;

  6: 

  7: while (ritor != s.rend())

  8: {

  9:   cout << *ritor << endl ;

 10:   ++ritor ;

 11: }

使用for

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s(a, a + 3) ;

  3: 

  4: set<int>::const_reverse_iterator ritor ;

  5: for (ritor = s.rbegin(); ritor != s.rend(); ++ritor)

  6: {

  7:   cout << *ritor << endl ;

  8: }

插入

插入单个值

  1: set<int> s ;

  2: s.insert(1) ;

批量插入

插入整个数组

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s ;

  3: s.insert(a, a + 3) ;

插入其他set的值

  1: int a[3] = {1, 2, 3} ;

  2: set<int> s(a, a + 3) ;

  3: 

  4: set<int> s1 ;

  5: s1.insert(s.begin(), s.end()) ;

删除

  1: set<int> s ;

  2: for (int i = 1; i <= 5; ++i)

  3:   s.insert(i) ;

  4: 

  5: set<int>::const_iterator citor ;

  6: citor = s.begin() ;

  7: ++citor ; // citor now point to 2

  8: 

  9: // 删除单个元素

 10: s.erase(citor) ; // erase 2 ; 

 11: 

 12: //批量删除

 13: citor = s.find(3) ; // itor now point to 3

 14: s.erase(citor, s.end()) ; // erase 3, 4, 5

 15: 

 16: //删除所有元素

 17: s.erase(s.begin(), s.end()) ;// erase all elements, same as s.clear()

查找

find

  1: set<int> s ;

  2: for (int i = 1; i <= 5; ++i)

  3:   s.insert(i) ;

  4: 

  5: set<int>::iterator itor ;

  6: itor = s.find(4) ;

  7: if(itor != s.end()) // itor point to s.end() if not found

  8:   cout << "found" ;

  9: else

 10:   cout << "not found" ;

count

  1: set<int> s ;

  2: for (int i = 1; i <= 5; ++i)

  3:   s.insert(i) ;

  4: 

  5: set<int>::iterator itor ;

  6: if(s.count(4) == 1) // return 1 if s contains 4, else 0

  7:   cout << "s contains 4" ;

  8: else

  9:   cout << "s does not contains 4" ;

排序

由于set本身是有序的，所以不提供排序函数。

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

int main()
{
    set<char* >s2;
    s2.insert("char *");
    cout<<*s2.begin()<<endl<<endl;

    puts("///-- set<int,greater<int> > --///");
    ///-- set<int,greater<int> > --///
    int a[9]={1,2,3,4,5,6,7,8,9};
    set<int,greater<int> >s(a,a+9); /// 初始化
    for(set<int,greater<int> >::iterator p=s.begin();p!=s.end();p++)
        cout<<*p<<" ";
    cout<<endl;

    puts("\n///-- set<int> --///");
    ///-- set<int> --///
    set<int>s1(s.begin(),s.end()); /// 初始化
    set<int>::iterator p;
    s1.insert(1);

    s1.insert(5);
    ///s1.clear();

    s1.insert(5);
    cout<<"erase:"<<s1.erase(5)<<endl; /// erase successfully return 1，otherwise return 0

    s1.insert(10);
    s1.insert(10);
    s1.insert(9);
    s1.insert(8);
    s1.insert(7);

    for(p=s1.begin();p!=s1.end();p++)
        cout<<*p<<" ";
    cout<<endl<<"size:"<<s1.size()<<endl;
    cout<<"count:"<<s1.count(4)<<endl;
    cout<<"empty:"<<s1.empty()<<endl;

    cout<<"lower_bound:"<<*s1.lower_bound(8)<<endl;
    cout<<"upper_bound:"<<*s1.upper_bound(8)<<endl;

    return 0;
}

/**
begin()
 返回指向第一个元素的迭代器
clear()
 清除所有元素
count()
 返回某个值元素的个数
empty()
 如果集合为空，返回true
end()
 返回指向最后一个元素的迭代器
equal_range()
 返回集合中与给定值相等的上下限的两个迭代器
erase()
 删除集合中的元素
find()
 返回一个指向被查找到元素的迭代器
get_allocator()
 返回集合的分配器
insert()
 在集合中插入元素
lower_bound()
 返回指向大于（或等于）某值的第一个元素的迭代器
key_comp()
 返回一个用于元素间值比较的函数
max_size()
 返回集合能容纳的元素的最大限值
rbegin()
 返回指向集合中最后一个元素的反向迭代器
rend()
 返回指向集合中第一个元素的反向迭代器
size()
 集合中元素的数目
swap()
 交换两个集合变量
upper_bound()
 返回大于某个值元素的迭代器
value_comp()
 返回一个用于比较元素间的值的函数
*/