第十一天之set和multiset容器

最新推荐文章于 2021-11-14 18:49:44 发布

李嘉图Y

最新推荐文章于 2021-11-14 18:49:44 发布

阅读量422

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/qq_42230338/article/details/103610163

版权

C/C++ 专栏收录该内容

78 篇文章 2 订阅

订阅专栏

set和multiset简介

set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按照一定的元素排列。
元素的插入过程是按照排序的规则插入的，所以不能指定插入的位置。

set是采用红黑树的变体的数据结构来实现的，红黑树采用的是平衡二叉树，在插入操作和删除操作上要比vector快
set不能直接存取元素。（不可以使用at(pos)与[]的方式访问元素）
multiset和set的区别是：set支持唯一键值，每一个元素只能出现一次；而multiset同一键值可以出现多次。
不可以直接修改set或multiset容器中的元素值，因为这类的容器是自动排序的，如果希望修改一个元素值，必须要先删除原来的元素值，再插入新的元素值
#include

在这里插入图片描述

set/miltiset对象的默认构造

set<int> setInt; //一个存放 int 的 set 容器。
set<float> setFloat; //一个存放 float 的 set 容器。
set<string> setString; //一个存放 string 的 set 容器。
multiset<int> mulsetInt; //一个存放 int 的 multi set 容器。
multi set<float> multisetFloat; //一个存放 float 的 multi set 容器。
multi set<string> multisetString; //一个存放 string 的 multi set 容器。

set的插入与迭代器

set.insert(elem); //在容器中插入元素。
set.begin(); //返回容器中第一个数据的迭代器。
set.end(); //返回容器中最后一个数据之后的迭代器。
set.rbegin(); //返回容器中倒数第一个元素的迭代器。
set.rend(); //返回容器中倒数最后一个元素的后面的迭代器。

set<int> setInt;
setInt.insert(3); setInt.insert(1);setInt.insert(5);setInt.insert(2);
for(set<int>::iterator it=setInt.begin(); it!=setInt.end(); ++it)
{
 int iItem = *it;
 cout << iItem; //或直接使用 cout << *it
}
//这样子便顺序输出 1 2 3 5。

set集合的元素排列

set<int,less > setIntA; //该容器是按升序方式排列元素。
set<int,greater> setIntB; //该容器是按降序方式排列元素。
set 相当于 set<int,less>。
less与 greater中的 int 可以改成其它类型，该类型主要要跟 set 容纳的数据类型一致。

疑问 1：less<>与 greater<>是什么？
疑问 2：如果 set<>不包含 int 类型，而是包含自定义类型，set 容器如何排序？
要解决如上两个问题，需要了解容器的函数对象，也叫伪函数，英文名叫 functor。
下面将讲解什么是 functor，functor 的用法

使用 stl 提供的函数对象
set<int,greater<int>> setIntB; 
setIntB.insert(3);
setIntB.insert(1);
setIntB.insert(5);
setIntB.insert(2);
此时容器 setIntB 就包含了按顺序的 5,3,2,1 元素

函数对象functor的用法

尽管函数指针被广泛用于实现函数回调，但 C++还提供了一个重要的实现回调函数
的方法，那就是函数对象。
functor，翻译成函数对象，伪函数，算符，是重载了“()”操作符的普通类对象。从
语法上讲，它与普通函数行为类似。
greater<>与 less<>就是函数对象。
下面举出 greater的简易实现原理。

下面举出 greater<int>的简易实现原理。
struct greater
{
bool operator() (const int& iLeft, const int& iRight)
{
 return (iLeft>iRight); //如果是实现 less<int>的话，这边是写 return (iLeft<iRight);
} }
容器就是调用函数对象的 operator()方法去比较两个值的大小。

题目：学生包含学号，姓名属性，现要求任意插入几个学生对象到 set 容器中，使得容器中的学生按学号的升序排序。

解：
//学生类
class CStudent
{
public:
CStudent(int iID, string strName)
{
m_iID = iID;
m_strName = strName;
}
 int m_iID; //学号
 string m_strName; //姓名
}
//为保持主题鲜明，本类不写拷贝构造函数，不类也不需要写拷贝构造函数。但大家仍要有
考虑拷贝构造函数的习惯

//函数对象
struct StuFunctor
{
bool operator() (const CStudent &stu1, const CStudent &stu2)
{
return (stu1.m_iID<stu2.m_iID);
} }
//main 函数
void main()
{
set<CStudent, StuFunctor> setStu;
setStu.insert(CStudent(3,"小张"));
setStu.insert(CStudent(1,"小李"));
setStu.insert(CStudent(5,"小王"));
setStu.insert(CStudent(2,"小刘"));
//此时容器 setStu 包含了四个学生对象，分别是按姓名顺序的“小李”，“小刘”，
“小张”，“小王”
}

set对象的拷贝构造与赋值

set(const set &st); //拷贝构造函数
set& operator=(const set &st); //重载等号操作符
set.swap(st); //交换两个集合容器

set<int> setIntA;
setIntA.insert(3);
setIntA.insert(1);
setIntA.insert(7);
setIntA.insert(5);
setIntA.insert(9);
set<int> setIntB(setIntA); //1 3 5 7 9
set<int> setIntC;
setIntC = setIntA; //1 3 5 7 9
setIntC.insert(6);
setIntC.swap(setIntA); //交换

set的大小

set.size(); //返回容器中元素的数目
set.empty();//判断容器是否为空

 
set<int> setIntA;
setIntA.insert(3);
setIntA.insert(1);
setIntA.insert(7);
setIntA.insert(5);
setIntA.insert(9);
if (!setIntA.empty())
{
int iSize = setIntA.size(); //5
}

set的删除

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

删除区间内的元素
setInt 是用 set<int>声明的容器，现已包含按顺序的 1,3,5,6,9,11 元素。
set<int>::iterator itBegin=setInt.begin();
++ itBegin;
set<int>::iterator itEnd=setInt.begin();
++ itEnd;
++ itEnd;
++ itEnd;
setInt.erase(itBegin,itEnd);
//此时容器 setInt 包含按顺序的 1,6,9,11 四个元素。
删除容器中第一个元素
setInt.erase(setInt.begin()); //6,9,11
删除容器中值为 9 的元素
set.erase(9); 
删除 setInt 的所有元素
setInt.clear(); //容器为空

set的查找

set.find(elem); //查找 elem 元素，返回指向 elem 元素的迭代器。
set.count(elem); //返回容器中值为 elem 的元素个数。对 set 来说，要么是 0，要
么是 1。对 multiset 来说，值可能大于 1。  set.lower_bound(elem); //返回第一个>=elem 元素的迭代器。
set.upper_bound(elem); // 返回第一个>elem 元素的迭代器。
set.equal_range(elem); //返回容器中与 elem 相等的上下限的两个迭代器。上
限是闭区间，下限是开区间，如[beg,end)。  以上函数返回两个迭代器，而这两个迭代器被封装在 pair 中。
以下讲解 pair 的含义与使用方法。

set<int> setInt;
setInt.insert(3);
setInt.insert(1);
setInt.insert(7);
setInt.insert(5);
setInt.insert(9);
set<int>::iterator itA = setInt.find(5);
int iA = *itA; //iA == 5
int iCount = setInt.count(5); //iCount == 1
set<int>::iterator itB = setInt.lower_bound(5);
set<int>::iterator itC = setInt.upper_bound(5);
int iB = *itB; //iB == 5
int iC = *itC; //iC == 7
pair< set<int>::iterator, set<int>::iterator > pairIt = setInt.equal_range(5); //pair 是什么？

pair的使用

pair 译为对组，可以将两个值视为一个单元。
pair<T1,T2>存放的两个值的类型，可以不一样，如 T1 为 int，T2 为 float。T1,T2 也可
以是自定义类型。
pair.first 是 pair 里面的第一个值，是 T1 类型。
pair.second 是 pair 里面的第二个值，是 T2 类型。

set<int> setInt;
... //往 setInt 容器插入元素 1,3,5,7,9
pair< set<int>::iterator , set<int>::iterator > pairIt = setInt.equal_range(5);
set<int>::iterator itBeg = pairIt.first;
set<int>::iterator itEnd = pairIt.second;
//此时 *itBeg==5 而 *itEnd == 7

小结：

一、容器 set/multiset 的使用方法；
红黑树的变体，查找效率高，插入不能指定位置，插入时自动排序。
二、functor 的使用方法；
类似于函数的功能，可用来自定义一些规则，如元素比较规则。
三、pair 的使用方法。
对组，一个整体的单元，存放两个类型(T1,T2，T1 可与 T2 一样)的两个元素。

案例：

set集合：

#define  _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;
#include "set"
#include <functional>
#include "algorithm"

//1、集合： 元素唯一  自动排序  不能按照数组[]的方式插入元素
//红黑树  平衡二叉树
void main91()
{
	set<int> s1;
	for (int i = 0;i < 5;i++)
	{
		int tmp = rand();
		s1.insert(tmp);
	}
	s1.insert(100);	//最终只插入一个100
	s1.insert(100);
	s1.insert(100);
	for (set<int>::iterator it = s1.begin();it != s1.end();it++)
	{
		cout << *it << " ";
	}
	//删除元素
	while (!s1.empty())
	{
		set<int>::iterator it = s1.begin();
		cout << *it << " ";
		s1.erase(s1.begin());

	}
}
//对基本的数据类型 set能自动的排序
void main92()
{
	set<int> s1;
	//默认集合从小到大排序 
	set<int, greater<int> > s2;	//从大到小排序
	for (int i = 0;i < 5;i++)
	{
		int tmp = rand();
		s2.insert(tmp);
	}
	//由大到小
	for (set<int, greater<int> >::iterator it = s2.begin();it != s2.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

class student {
public:
	student(char* name,int age)
	{
		strcpy(this->name, name);
		this->age = age;
	}
public:
	char name[64];
	int age;

};
//仿函数
struct funcStudent
{
	bool operator()(const student& left, const student& right)
	{
		if (left.age < right.age)	//按照年龄排序
		{
			return true;
		}
		else
			return false;
	}
};
//typedef pair<iterator, bool> _Pairib
//对复杂的数据类型，如何排序
void main93()
{
	student s1("s1", 31);
	student s2("s2", 25);
	student s3("s3", 32);
	student s4("s4", 22);
	student s5("s1", 31);	//两个31 用pair判断返回值
	set<student, funcStudent > s;
	pair<set<student, funcStudent >::iterator, bool> pair1 = s.insert(s1);
	if (pair1.second ==true)
	{
		cout << "插入s1成功"<<endl;
	}
	else
		cout << "插入s1失败" << endl;
	s.insert(s2);
	s.insert(s3);
	s.insert(s4);
	pair<set<student, funcStudent >::iterator, bool> pair5 = s.insert(s5);
	if (pair5.second == true)
	{
		cout << "插入s5成功" << endl;
	}
	else
		cout << "插入s5失败" << endl;
	//遍历
	for (set<student, funcStudent >::iterator it = s.begin(); it != s.end();it++)
	{
		cout << it->age << "\t" << it->name << endl;
	}

}

void main94()
{
	set<int> s1;
	for (int i = 0;i < 10;i++)
	{
		s1.insert(i+1);
	}

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

	set<int>::iterator it1 = s1.find(5);
	cout <<  "it1 " <<*it1 << endl;

	int num = s1.count(5);
	cout << "unm: " << num << endl;

	set<int>::iterator it2 = s1.lower_bound(5);	//小于等于5的迭代器的位置
	cout << "it2 " << *it2 << endl;				//大于等于5的迭代器的位置

	set<int>::iterator it3 = s1.upper_bound(5);
	cout << "it3 " << *it3 << endl;

	//typedef pair<iterator, bool> _Pairib
	pair< set<int>::iterator, set<int>::iterator > pair3 = s1.equal_range(5);//返回两个迭代器的位置 第一个是等于的 第二个是大于的
	set<int>::iterator it4 = pair3.first;
	cout << "it4 " << *it4 << endl;
	set<int>::iterator it5 = pair3.second;
	cout << "it5 " << *it5 << endl;
}
void main09()
{
	//main91();
	//main92();
	//main93();
	main94();
	system("pause");
}

multiset集合：

#define  _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;
#include "set"
#include <functional>
#include "algorithm"

void main101()
{
	multiset<int> m;
	int tmp;
	cout << "请输入值：";
	cin >> tmp;
	while (tmp!=0)
	{
		m.insert(tmp);
		cout << "请输入值：";
		cin >> tmp;
	}
	for (multiset<int>::iterator it = m.begin();it != m.end();it++)
	{
		cout << *it << " ";
		
	}
	cout << endl;
	while (!m.empty())
	{
		multiset<int>::iterator it = m.begin();
		cout << *it << " ";
		m.erase(it);
	}
}

void main()
{
	main101();
	system("pause");
}

李嘉图Y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十一天之set和multiset容器

set和multiset简介set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按照一定的元素排列。元素的插入过程是按照排序的规则插入的，所以不能指定插入的位置。set是采用红黑树的变体的数据结构来实现的，红黑树采用的是平衡二叉树，在插入操作和删除操作上要比vector快set不能直接存取元素。（不可以使用at(pos)与[]的方式访问元素）multiset和set的区别是：se...
复制链接

扫一扫