STL(set/multiset容器)

最新推荐文章于 2024-02-14 09:44:20 发布

塞外听雪

最新推荐文章于 2024-02-14 09:44:20 发布

阅读量170

点赞数

分类专栏： STL 文章标签： stl

本文链接：https://blog.csdn.net/qq_42754132/article/details/100058408

版权

STL 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

3.7 set/multiset容器

3.7.1 set/multiset容器基本概念

3.7.1.1 set容器基本概念

Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。

我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.

set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。

3.7.1.2 multiset容器基本概念

multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。

树的简单知识：

二叉树就是任何节点最多只允许有两个字节点。分别是左子结点和右子节点。

二叉树示意图

二叉搜索树，是指二叉树中的节点按照一定的规则进行排序，使得对二叉树中元素访问更加高效。二叉搜索树的放置规则是：任何节点的元素值一定大于其左子树中的每一个节点的元素值，并且小于其右子树的值。因此从根节点一直向左走，一直到无路可走，即得到最小值，一直向右走，直至无路可走，可得到最大值。那么在儿茶搜索树中找到最大元素和最小元素是非常简单的事情。下图为二叉搜索树：

上面我们介绍了二叉搜索树，那么当一个二叉搜索树的左子树和右子树不平衡的时候，那么搜索依据上图表示，搜索9所花费的时间要比搜索17所花费的时间要多，由于我们的输入或者经过我们插入或者删除操作，二叉树失去平衡，造成搜索效率降低。

所以我们有了一个平衡二叉树的概念，所谓的平衡不是指的完全平衡。

RB-tree(红黑树)为二叉树的一种。

3.7.2 set常用API

3.7.2.1 set构造函数

set<T> st;//set默认构造函数：

mulitset<T> mst; //multiset默认构造函数:

set(const set &st);//拷贝构造函数

3.7.2.2 set赋值操作

set& operator=(const set &st);//重载等号操作符

swap(st);//交换两个集合容器

3.7.2.3 set大小操作

size();//返回容器中元素的数目

empty();//判断容器是否为空

3.7.2.4 set插入和删除操作

insert(elem);//在容器中插入元素。

clear();//清除所有元素

erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

erase(elem);//删除容器中值为elem的元素。

3.7.2.5 set查找操作

find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();

count(key);//查找键key的元素个数

lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。

upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。

equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

set的返回值指定set排序规则:

//插入操作返回值

void test01(){

set<int> s;

pair<set<int>::iterator,bool> ret = s.insert(10);

if (ret.second){

cout << "插入成功:" << *ret.first << endl;

}

else{

cout << "插入失败:" << *ret.first << endl;

}

ret = s.insert(10);

if(ret.second){

cout << "插入成功:" << *ret.first << endl;

}

else{

cout << "插入失败:" << *ret.first << endl;

}

struct MyCompare02{

bool operator()(int v1,int v2){

return v1 > v2;

}

};

//set从大到小

void test02(){

srand((unsigned int)time(NULL));

//我们发现set容器的第二个模板参数可以设置排序规则，默认规则是less<_Kty>

set<int, MyCompare02> s;

for (int i = 0; i < 10;i++){

s.insert(rand() % 100);

}

for (set<int, MyCompare02>::iterator it = s.begin(); it != s.end(); it ++){

cout << *it << " ";

}

cout << endl;

}

//set容器中存放对象

class Person{

public:

Person(string name,int age){

this->mName = name;

this->mAge = age;

}

public:

string mName;

int mAge;

};

struct MyCompare03{

bool operator()(const Person& p1,const Person& p2){

return p1.mAge > p2.mAge;

}

};

void test03(){

set<Person, MyCompare03> s;

Person p1("aaa", 20);

Person p2("bbb", 30);

Person p3("ccc", 40);

Person p4("ddd", 50);

s.insert(p1);

s.insert(p2);

s.insert(p3);

s.insert(p4);

for (set<Person, MyCompare03>::iterator it = s.begin(); it != s.end(); it++){

cout << "Name:" << it->mName << " Age:" << it->mAge << endl;

}

08 set 容器
关联式容器
插入数据自动排序按照key值
insert插入值
rease 参数可以传值或者迭代器
find()返回值是迭代器找不到返回end位置
count 计数对于set而言结果就是0或1
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
set插入返回值是对组<迭代器，是否成功表示>
指定set排序规则，利用仿函数
//指定set排序规则从大到小
//仿函数，重载是见过是一个类
//和函数唯一区别就是它是一个类型
class myCompare
{
public:
//重载 ()
bool operator()(int v1, int v2)
{
return v1 > v2;//降序
}
};
set插入自定义数据类型使用的也是仿函数和自定义的排序规则

#include<iostream>
using namespace std;
//set  multiset头文件
#include <set>
#include <string>

/*
1 set构造函数
set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数:
set(const set &st);//拷贝构造函数

2 set赋值操作
set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器

3 set大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空

4 set插入和删除操作
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。

*/

void printSet(set<int>& s)
{
    for (set<int>::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    set<int>s1;
    //关联式容器 key进行排序，从小到大
    s1.insert(5);
    s1.insert(1);
    s1.insert(9);
    s1.insert(3);
    s1.insert(7);
    printSet(s1);

    if (s1.empty())
    {
        cout << "空" << endl;
    }
    else
    {
        cout << "size = " << s1.size() << endl;
    }

    //删除操作
    s1.erase(s1.begin()); // 3 5 7 9
    printSet(s1);
    s1.erase(3); //  5 7 9
    printSet(s1);
}

/*
5 set查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//查找键key的元素个数
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

*/

void test02()
{
    set<int>s1;
    s1.insert(5);
    s1.insert(1);
    s1.insert(9);
    s1.insert(3);
    s1.insert(7);
    //对于set而言 没有 value key就是value

    set<int>::iterator pos = s1.find(3);
    //判断是否找到
    if (pos != s1.end())
    {
        cout << "找到了：" << *pos << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }

    //count(key);//查找键key的元素个数 set而言 结果 0或者1

    int num = s1.count(1);
    cout << "1的个数为： " << num << endl;


    //lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
    set<int>::iterator it = s1.lower_bound(3); // 10就是未找到
    if (it != s1.end())
    {
        cout << "找到了 lower_bound (3)的值为：" << *it << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }


    // upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
    set<int>::iterator it2 = s1.upper_bound(3);
    if (it2 != s1.end())
    {
        cout << "找到了 upper_bound (3)的值为：" << *it2 << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }

    //equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
    //上下限 就是lower_bound   upper_bound
    //pair对儿组
    pair<set<int>::iterator, set<int>::iterator>  ret = s1.equal_range(3);

    //获取第一个值
    if (ret.first != s1.end())
    {
        cout << "找到equal_range中 lower_bound 的值 ：" << *(ret.first) << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }

    //获取第二个值
    if (ret.second != s1.end())
    {
        cout << "找到equal_range中 upper_bound 的值 ：" << *(ret.second) << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }

}



//set容器 不允许插入重复的键值
void test03()
{
    set<int> s1;
   s1.insert(10);
   s1.insert(10);


    pair<set<int>::iterator, bool> ret = s1.insert(10);

    if (ret.second)//true
    {
        cout << "插入成功" << endl;
    }
    else
    {
        cout << "插入失败" << endl;
    }

    ret = s1.insert(10);
    if (ret.second)
    {
        cout << "第二次插入成功" << endl;
    }
    else
    {
        cout << "第二次插入失败" << endl;
    }

    printSet(s1);

///multiset允许插入重复值
  multiset<int> mul;
   mul.insert(10);
   mul.insert(10);

}






//指定set排序规则 从大到小
//仿函数，重载是见过 是一个类
//和函数唯一区别就是它是一个类型
class myCompare
{
public:
    //重载 ()
    bool operator()(int v1, int v2)
    {
        return v1 > v2;//降序
    }
};


//set容器排序
void test04()
{
    set<int, myCompare>s1;//仿函数 规则，自己指定
//在插入前指定规则
    s1.insert(5);
    s1.insert(1);
    s1.insert(9);
    s1.insert(3);
    s1.insert(7);

    //printSet(s1);

    //从大到小排序
    //在插入之前就指定排序规则

    //自己写迭代输出
    for (set<int, myCompare>::iterator it = s1.begin(); it != s1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;


    myCompare my;
    cout<<my(2,2)<<endl;
}


//自定义数据类型
class Person{
public:
    Person(string name,int age){
        this->mName=name;
        this->mage=age;
    }
    string mName;
    int mage;
};

class myComparePerson{
public:
    bool operator()(const Person &p1,const Person &p2){//只读
        if(p1.mage>p2.mage){
            return true;
        }
        return false;
    }
};


void test05(){
  // set<Person> s1;
    set<Person,myComparePerson> s1;
    Person p1("aa",100);
    Person p2("bb",90);
    Person p3("cc",10);
    Person p4("dd",1000);

    s1.insert(p1);
    s1.insert(p2);
    s1.insert(p3);
    s1.insert(p4);
//插入自定义数据类型，上来就指定好排序规则

//显示
    for(set<Person,myComparePerson>::iterator it=s1.begin();it!=s1.end();it++){
        cout<<"姓名:"<<(*it).mName<<"\t"<<"年龄："<<it->mage<<endl;
    }

}



int main() {

   // test01();

   // test02();

    //test03();

    //test04();

    test05();
    return 0;
}

(本笔记整理自网络资源，侵删)

塞外听雪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
STL(set/multiset容器)

3.7 set/multiset容器3.7.1 set/multiset容器基本概念3.7.1.1 set容器基本概念Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素...
复制链接

扫一扫