C++ STL(八)容器_set和multiset

set(集合)是一个集合容器，容器中的元素是唯一的，元素即是键值又是实值，集合中的元素按一定的顺序排序.属于关联式容器的一种.

元素插入过程是按排序规则插入，不能指定插入位置.

它不支持随机存取元素，不能使用数组[]和at方式进行访问.

set与multiset区别：set每个元素值在容器中只能出现一次，而multiset可以出现多次

所需头文件：#include<set>

构造函数：

    //set
    set<int> setA; //构造个空的set
    set<int> setB(setA); //通过setA拷贝构造一个set (setB=setA)
    int nArray[] = {1,2,3};
    int nLeng = sizeof(nArray)/sizeof(int);
    set<int> setC(nArray, nArray+nLeng); //通过数组拷贝构造一个setC (setC={1,2,3})
    //使用迭代器构造    
    set<int> dIt(setC.begin(),setC.end()); //正向迭代器方式构造set (dIt={1,2,3,4,5})
    set<int> dRit(setC.rbegin(), setC.rend()); //反向迭代器方式构造set (dRit={5,4,3,2,1})
    
    //multiset
    multiset<int> multisetA; //构造个空的multiset
    multiset<int> multisetB(multisetA); //通过multisetA拷贝构造一个multiset (multisetB=multisetA)
    nLeng = sizeof(nArray)/sizeof(int);
    multiset<int> multisetC(nArray, nArray+nLeng); //通过数组拷贝构造一个multisetC (multisetC={1,2,3})
    //使用迭代器构造
    multiset<int> dItM(multisetC.begin(), multisetC.end()); //正向迭代器方式构造multisetC (dItM={1,2,3,4,5})
    multiset<int> dRiM(multisetC.rbegin(), multisetC.rend()); //反向迭代器方式构造multisetC (dRiM={5,4,3,2,1})

    return;

增加元素操作：

注意：set中元素是唯一的，无法插入重复的元素.multiset中可以插入重复的元素. 二种容器插入后都会自动进行排序

    //set中元素是唯一的，无法插入重复的元素
    set<int> setA;
    setA.insert(1);
    setA.insert(2);
    setA.insert(3);
    pair<set<int>::iterator,int> pairSet;
    pairSet = setA.insert(2); //此时由于容器中己有元素值2，就不会插入新元素2. 此时setA={1,2,3}
    //根据返回值pair的第二个参数可以发现插入失败
    if(pairSet.second == 0)
    {
        printf("set插入失败
");
    }
    else if(pairSet.second == 1)
    {
        printf("set插入成功
");
    }
    //迭代器方式插入
    setA.insert(setA.end(),4); //setA={1,2,3,4}
    set<int> setB;
    setB.insert(setA.begin(), setA.end()); //把setA中所有元素插入到setB中


    //multiset中可以插入重复的元素
    multiset<int>::iterator it;
    multiset<int> multisetA;
    multisetA.insert(1); 
    multisetA.insert(2); 
    it = multisetA.insert(3); //it指向插入后新元素3的位置
    it = multisetA.insert(2); //it指向插入后新元素2的位置，证明multiset可以插入重复的元素
    //迭代器方式插入
    multisetA.insert(multisetA.end(),4); //multisetA={1,2,2,3,4}
    multiset<int> multisetB;
    multisetB.insert(multisetA.begin(), multisetA.end()); //把multisetA中所有元素插入到multisetB中

    //注意：set的insert()返回的是pair,而multiset返回的是指向插入后新元素位置的迭代器
    return;

删除元素操作：

注意：set中元素是唯一的，所以删除时只会删除1个元素.multiset中元素可以是重复的，所以根据key进行删除时只要相同的都会批量删除

    //set中元素是唯一的，所以删除时只会删除1个元素
    set<int> setA;
    setA.insert(1);
    setA.insert(2);
    setA.insert(3);

    setA.erase(1); //删除元素1  setA={2,3}
    setA.erase(setA.begin()); //使用迭代器删除指向开始位置的元素 setA={3}
    setA.clear(); //清除所有元素


    //multiset中元素可以是重复的，所以根据key进行删除时只要相同的都会批量删除
    multiset<int> multisetA;
    multisetA.insert(1);
    multisetA.insert(1);
    multisetA.insert(2);

    multisetA.erase(1); //所有元素值为1的元素都被删除了，最终multisetA={2}
    multisetA.erase(multisetA.begin()); //使用迭代器删除指向开始位置的元素 multisetA={}
    multisetA.clear(); //清除所有元素

    return;

获取大小：

empty()  返回是否为空

size()     返回大小

max_size()  返回所能存储的最大元素个数,这是由系统自动定义的值

    //set
    set<int> setA;
    bool bEmpty = setA.empty(); //bEmpty = true
    int nSize = setA.size();    //nsize = 0
    setA.insert(1);
    bEmpty = setA.empty(); //bEmpty = false
    nSize = setA.size();  //nSize = 1
    int nMaxSize = setA.max_size(); //nMaxSize = 214748364 所能存储的最大元素个数,这是由系统自动定义的值

    //mulitset
    multiset<int> multisetA;
    bEmpty = multisetA.empty(); //bEmpty = true
    nSize = multisetA.size();    //nsize = 0
    multisetA.insert(1);
    multisetA.insert(1);
    bEmpty = multisetA.empty(); //bEmpty = false
    nSize = multisetA.size();  //nSize = 2
    nMaxSize = multisetA.max_size(); 

    return;

查找操作：

find()  根据元素值进行查找，返回第一个找到的迭代器

count(key) 根据元素值进行查找，返回元素个数. 注意: set返回的只有可能是0或者1，而multiset返回的可能是0和>0的元素个数

lower_bound(elem) 返回第一个>=elem元素的迭代器

upper_bound(elem) 返回第一个> elem元素的迭代器

equal_range(elem) 返回容器中与elem相等的包含上下限二个迭代器的pair

    set<int> setInt;
    setInt.insert(11);
    setInt.insert(13);
    setInt.insert(22);
    setInt.insert(9);
    setInt.insert(7);

    //find 根据元素值进行查找，返回第一个找到的迭代器
    set<int>::iterator it = setInt.find(9);
    int nValue = *it; //nValue = 9

    //count 根据元素值进行查找，返回元素个数
    //因为set中元素是唯一的，所以count()返回的只有可能是0或者是1
    //而multiset中元素值可以是重复的，所以count()值可以是0，或者>=1
    int nCount = setInt.count(99); //没有找到元素值为99的元素，nCount=0
    nCount = setInt.count(7); //nCount = 1

    //lower_bound(elem) 返回第一个>=elem元素的迭代器
    //upper_bound(elem) 返回第一个> elem元素的迭代器
    set<int>::iterator itLower = setInt.lower_bound(13); //*itLower = 13
    set<int>::iterator itUpper = setInt.upper_bound(13); //*itUpper = 22

    //equal_range(elem) 返回容器中与elem相等的包含上下限二个迭代器的pair
    //pair是个对组，包含二个迭代器，first与second
    //pair.first 查找的元素值所在的迭代器
    //pair.second 查找的元素值所在的下一个迭代器
    pair<set<int>::iterator, set<int>::iterator> itPair = setInt.equal_range(13);
    set<int>::iterator itFirst = itPair.first; //*itFirst = 13
    set<int>::iterator itSecond = itPair.second; //*itSecond = 22

    return;

排序操作：

1.自动排序: 定义set和multiset时使用缺省排序或者显示指明容器排序方式. 注意：只能排序基本数据类型

    //自动排序,只能排序基本数据类型
    set<int> setA; //set和multiset使用缺省的排序方式，也就是升序排序
    set<int,less<int>> setLess; //setB和setA是等价的都是升序排序
    set<int,greater<int>> setGreater; //使用降序排序

    setA.insert(3);
    setA.insert(1);
    setA.insert(2);  //此时由于setA使用默认的升序排序，setA={1,2,3}

    setLess.insert(3);
    setLess.insert(1);
    setLess.insert(2); //此时由于setB和setA一样也是使用升序排序，setLess={1,2,3}

    setGreater.insert(3);
    setGreater.insert(1);
    setGreater.insert(2); //此时由于setGreater使用降序排序，setGreater={3,2,1}

    return;

2.编写排序函数排序：

学生包含学号，姓名属性，现要求插入几个学生对象到set容器中，使得容器中的学生按学号的升序排列.

class CStudent
{
public:
    CStudent(int nId, string strName)
    {
        m_nId = nId;  //学号
        m_strName = strName; //学生名字
    }
public:
    int m_nId;
    string m_strName;
};

struct StuFunctor
{
    bool operator()(const CStudent &stu1, const CStudent &stu2)
    {
        return (stu1.m_nId<stu2.m_nId); //根据nId学号进行升序排列
        //return (stu1.m_nId>stu2.m_nId); //根据nId学号进行降序排列
    }
};

inline void SortByFunction()
{
    //函数对象functor的用法
    //学生包含学号，姓名属性，现要求插入几个学生对象到
    //set容器中，使得容器中的学生按学号的升序排列.
    set<CStudent,StuFunctor> setStu; //定义set时指定使用自定义排序函数
    setStu.insert(CStudent(3,"小张"));
    setStu.insert(CStudent(1,"小李"));
    setStu.insert(CStudent(5,"小王"));
    setStu.insert(CStudent(2,"小刘"));
    set<CStudent,StuFunctor>::iterator it = setStu.begin();
    for (it; it!=setStu.end(); ++it)
    {
        cout<<it->m_nId <<":"<<it->m_strName.c_str()<<endl;
    }

    getchar();
    return;
}

输出结果：