C++学习笔记（六）STL-常用算法

于 2023-08-14 22:06:04 发布
阅读量100 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zz_0000000/article/details/132282782
版权

此 C++ 系列的笔记，是根据黑马程序员的 C++ 视频教程所写。这部分是算法，是整个 C++ 语言中最重要的部分之一

函数对象

  • 就是重载了()运算符，因为调用函数的时候也是使用的()，因此，也称为函数对象或者仿函数，但是实际上是个类（而类名，其实就是仿函数的函数名了）

函数对象使用

  • 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值（在前面类与对象2中说明的一样）
  • 函数对象超出普通函数的概念，函数对象可以有自己的状态（就是可以在类内定义一个成员变量，记录这个重载运算符的调用状态，如：次数）
  • 函数对象可以作为参数传递

注：其实就是说，这个类重载的()运算符可以当做函数来使用

//1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
//其实这里的类名就是这个仿函数的函数名了
class MyAdd{
public :
	int operator()(int v1,int v2){
		return v1 + v2;
	}
};
void test01(){
	MyAdd myAdd;
    //与调用普通函数一样，有参数，有返回值
	cout << myAdd(10, 10) << endl;
}
//2、函数对象可以有自己的状态
class MyPrint{
public:
	MyPrint(){
		count = 0;
	}
	void operator()(string test){
		cout << test << endl;
		count++; //统计使用次数
	}
	int count; //内部自己的状态
};
void test02(){
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	cout << "myPrint调用次数为： " << myPrint.count;
}
//3、函数对象可以作为参数传递
//就是下面这个函数的形参，可以将这个类传入，就是函数对象传入
void doPrint(MyPrint &mp , string test){
	mp(test);
}
void test03(){
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}

谓词

  • 返回bool类型的仿函数称为谓词（这是前提）
  • 如果operator()接受一个参数，那么叫做一元谓词
  • 如果operator()接受两个参数，那么叫做二元谓词

注：谓词主要是为后面的算法服务的，比如之前的自定义降序排序，就是通过bool类型的仿函数作为算法函数的参数，使得算法得到自定义的结果。（对于算法函数对输入参数中的仿函数的要求主要是看算法函数的内部是如何定义的，所以，我们只需要记住常用算法是这么写就行了）

一元谓词

//1.一元谓词
struct GreaterFive{
    //首先是bool类型的返回值，然后只有一个参数，就是一元谓词
    //下面就是输入的值大于5，就会返回true
	bool operator()(int val) {
		return val > 5;
	}
};
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++){
		v.push_back(i);
	}
	//find_if就是按照自定义的方式寻找容器中的数据，如果找到了就返回这个数据的迭代器（就是指针）
    //对这个算法函数先是输入了范围（begin和end），然后是一元谓词，就是自定义的寻找规则，可以直接使用类名表示这个仿函数
    //也可以按照上一节中，先定义一个类，再把类放到这里
    //这里的GreaterFive()的()中并没有输入参数，因为这是一个匿名对象的创建
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "没找到!" << endl;
	}
	else {
		cout << "找到:" << *it << endl;
	}
}

二元谓词

//二元谓词  跟之前的排序算法一样的使用
class MyCompare{
public:
	bool operator()(int num1, int num2){
		return num1 > num2;
	}
};
void test01(){
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	//默认从小到大
	sort(v.begin(), v.end());
	//使用函数对象改变算法策略，排序从大到小
    //这里的仿函数的()依然没有参数传入，因为这是匿名对象的创建
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
}

内建函数对象

  • 就是上面所说的仿函数（函数对象），只不过这些是stl内部写好的仿函数，因此需要包含头文件#include <functional>
  • 主要分为三类：
    • 算术仿函数
    • 关系仿函数
    • 逻辑仿函数
  • 注：这些仿函数与我们正常使用的差不多，因此，可以自己写，也可以使用内建仿函数（爱用不用）

算术仿函数

  • 就是四则运算，加上取反仿函数（这里的取反，是指取负数）
  • 其中negate（取反）是一元运算，其他都是二元运算
  • 函数原型：
    • template<class T> T plus<T> 加法仿函数
    • template<class T> T minus<T> 减法仿函数
    • template<class T> T multiplies<T> 乘法仿函数
    • template<class T> T divides<T> 除法仿函数
    • template<class T> T modulus<T> 取模仿函数
    • template<class T> T negate<T> 取反仿函数
//其实下面的仿函数的应用我们大可以使用正常的+-*/的符号运算
//因此说，爱用不用
//negate取反
void test01(){
	negate<int> n;
	cout << n(50) << endl;   //-50
}
//plus 加法
void test02(){
	plus<int> p;
	cout << p(10, 20) << endl;  //30
}

关系仿函数

  • 函数原型：
    • template<class T> bool equal_to<T> 等于
    • template<class T> bool not_equal_to<T> 不等于
    • template<class T> bool greater<T> 大于
    • template<class T> bool greater_equal<T> 大于等于
    • template<class T> bool less<T> 小于
    • template<class T> bool less_equal<T> 小于等于
//下面是自定义实现的仿函数，用于降序
class MyCompare{
public:
	bool operator()(int v1,int v2){
		return v1 > v2;
	}
};
void test01(){
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);
	v.push_back(20);
    //无论是自己写的，还是使用内建的，都是一样的效果
	//自己实现仿函数
	//sort(v.begin(), v.end(), MyCompare());
	//STL内建仿函数  大于仿函数  降序  这里需要指定是int的
	sort(v.begin(), v.end(), greater<int>());
}

逻辑仿函数

  • 函数原型：
    • template<class T> bool logical_and<T> 逻辑与
    • template<class T> bool logical_or<T> 逻辑或
    • template<class T> bool logical_not<T> 逻辑非
void test01(){
	vector<bool> v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	//逻辑非  将v容器搬运到v2中，并执行逻辑非运算
	vector<bool> v2;
	v2.resize(v.size());
    //transform搬运算法，将v搬运到v2，并取反，这里的取反就是使用的内建仿函数，这里是bool类型
	transform(v.begin(), v.end(),  v2.begin(), logical_not<bool>());
}

常用算法

  • 算法主要是由头文件<algorithm> <functional> <numeric>组成
    • <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等
    • <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数
    • <functional>定义了一些模板类,用以声明函数对象。

常用遍历算法

for_each
  • 实现遍历容器
  • 函数原型：
  • for_each(iterator beg, iterator end, _func);
    • 遍历算法 遍历容器元素
    • beg 开始迭代器
    • end 结束迭代器
    • _func 函数或者函数对象
//普通函数
void print01(int val) {
	cout << val << " ";
}
//函数对象
class print02 {
 public:
	void operator()(int val) {
		cout << val << " ";
	}
};
//for_each算法基本用法
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	//遍历算法
    //这里使用的普通函数作为遍历的规则，只需要使用函数名称
	for_each(v.begin(), v.end(), print01);
    //这里使用的仿函数作为遍历的规则，因此需要()作为匿名对象
	for_each(v.begin(), v.end(), print02());
}
transform
  • 搬运容器到另一个容器中
  • 函数原型：
  • transform(iterator beg1, iterator end1, iterator beg2, _func);
    • beg1 源容器开始迭代器
    • end1 源容器结束迭代器
    • beg2 目标容器开始迭代器–传入数据的容器
    • _func 函数或者函数对象–指的是在传入的过程中可以添加的逻辑
//常用遍历算法  搬运 transform
class TransForm{
public:
	int operator()(int val){
		return val+100;
	}
};
class MyPrint{
public:
	void operator()(int val){
		cout << val << " ";
	}
};
void test01(){
	vector<int>v;
	for (int i = 0; i < 10; i++){
		v.push_back(i);
	}
	vector<int>vTarget; //目标容器
	//目标容器需要提前开辟空间，如果不开辟空间会报错
	vTarget.resize(v.size()); 
	//可以在遍历容器搬运的时候，添加一下逻辑，比如+100
	transform(v.begin(), v.end(), vTarget.begin(), TransForm());
	for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

常用查找算法

find
  • 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
  • 函数原型：
  • find(iterator beg, iterator end, value);
    • 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
    • beg 开始迭代器
    • end 结束迭代器
    • value 查找的元素
  • 注：查找自定义的数据类型时，需要重载==运算符
//查找普通数据类型
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	//查找容器中是否有 5 这个元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it == v.end()) {
		cout << "没有找到!" << endl;
	}
	else {
		cout << "找到:" << *it << endl;
	}
}
//查找自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
    //因为find算法底层并不知道你要怎么找这个自定义的数据
    //因此，需要重载==运算符
	bool operator==(const Person& p) {
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {
			return true;
		}
		return false;
	}
	string m_Name;
	int m_Age;
};
void test02() {
	vector<Person> v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	//重载之后，find就知道怎么查找自定义的数据类型
	vector<Person>::iterator it = find(v.begin(), v.end(), p2);
	if (it == v.end()) {
		cout << "没有找到!" << endl;
	}
	else {
		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
	}
}
find_if
  • 按照条件查找元素
  • 函数原型：
  • find_if(iterator beg, iterator end, _Pred);
    • 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置（是从左到右查找，因此只会返回一个）
    • beg 开始迭代器
    • end 结束迭代器
    • _Pred 函数或者谓词（返回bool类型的仿函数）
//内置数据类型
class GreaterFive{
public:
	bool operator()(int val){
		return val > 5;
	}
};
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
}
//自定义数据类型
class Person {
public:
	Person(string name, int age){
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class Greater20{
public:
	bool operator()(Person &p){
		return p.m_Age > 20;
	}
};
void test02() {
	vector<Person> v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	//使用仿函数自定义规则
	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
	if (it == v.end()){
		cout << "没有找到!" << endl;
	}
	else{
		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;  //返回的是ccc的数据
	}
}
adjacent_find
  • 查找相邻重复的元素
  • 函数原型：
  • adjacent_find(iterator beg, iterator end);
    • 查找相邻重复元素,返回相邻元素的第一个位置的迭代器，找不到就返回end()
    • beg 开始迭代器
    • end 结束迭代器
void test01(){
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	v.push_back(4);
	v.push_back(3);
	//查找相邻重复元素
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it == v.end()) {
		cout << "找不到!" << endl;
	}
	else {
		cout << "找到相邻重复元素为:" << *it << endl;
	}
}
biinary_search
  • 查找指定元素是否存在（返回的是bool类型，二分法查找快）
  • 函数原型：
  • bool binary_search(iterator beg, iterator end, value);
    • 查找指定的元素，查到 返回true 否则false
    • 注意: 在无序序列中不可用，必须是升序的容器，否则找不到
    • beg 开始迭代器
    • end 结束迭代器
    • value 查找的元素
void test01(){
	vector<int>v;
	for (int i = 0; i < 10; i++){
		v.push_back(i);
	}
	//二分查找
    //这里是升序的，因此能够查到
    //如果在容器最后添加一个2，那么就找不到，直接返回false
	bool ret = binary_search(v.begin(), v.end(),2);
	if (ret){
		cout << "找到了" << endl;
	}
	else{
		cout << "未找到" << endl;
	}
}
count
  • 统计元素的个数
  • 函数原型：
  • count(iterator beg, iterator end, value);
    • 返回在容器中出现value的个数（int类型）
    • beg 开始的迭代器
    • end 结束的迭代器
    • value统计的元素，可以使用自定义的数据类型，但是需要重载==元素符，因为底层是使用＝＝去对比的
//内置数据类型
void test01(){
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(4);
	int num = count(v.begin(), v.end(), 4);
	cout << "4的个数为： " << num << endl;
}
//自定义数据类型
class Person{
public:
	Person(string name, int age){
		this->m_Name = name;
		this->m_Age = age;
	}
    //需要重载==运算符，要不然编译器并不知道你要怎么找
	bool operator==(const Person & p){
		if (this->m_Age == p.m_Age){
			return true;
		}
		else{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};
void test02(){
	vector<Person> v;
	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p5("曹操", 25);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p5);
    //定义一个你要查找的类型
    Person p("诸葛亮",35);
	//在容器里寻找，跟p数据相同的数据个数
	int num = count(v.begin(), v.end(), p);
	cout << "num = " << num << endl;
}
count_if
  • 按照条件去统计元素的个数
  • 函数原型：
  • count_if(iterator beg, iterator end, _Pred);
    • 按照条件统计元素个数（使用谓词）
    • beg 开始的迭代器
    • end 结束的迭代器
    • _pred 谓词
//内置数据类型
class Greater4{       //一元谓词
public:
	bool operator()(int val){
		return val >= 4;
	}
};
void test01(){
	vector<int> v;
	v.push_back(1);
	v.push_back(4);
	v.push_back(4);
	int num = count_if(v.begin(), v.end(), Greater4());
	cout << "大于4的个数为： " << num << endl;
}
//自定义数据类型
class Person{
public:
	Person(string name, int age){
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
//自定义数据类型
class AgeLess35{　　//一元谓词
public:
	bool operator()(const Person &p){
		return p.m_Age < 35;
	}
};
void test02(){
	vector<Person> v;
	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p5);
	int num = count_if(v.begin(), v.end(), AgeLess35());
	cout << "小于35岁的个数：" << num << endl;
}

常用排序算法

sort
  • 对容器内的元素进行排序
  • 函数原型：
  • sort(iterator beg, iterator end, _Pred);
    • 默认从小到大的排序
    • beg 开始的迭代器
    • end 结束的迭代器
    • _pred 谓词
void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(40);
	//sort默认从小到大排序
	sort(v.begin(), v.end());
	//从大到小排序
    //下面使用内建函数（STL内部建立的仿函数，可以直接使用）
	sort(v.begin(), v.end(), greater<int>());
}
random_shuffle
  • 洗牌，将容器内元素打乱，随机调整次序
  • 函数原型：
  • random_shuffle(iterator beg, iterator end);
    • 在指定的范围内打乱顺序（按照随机种子进行打乱）
    • beg 开始的迭代器
    • end 结束的迭代器
void test01(){
    //使用系统时间作为随机种子，这样每次运行后的随机打乱才是真正的随机
	srand((unsigned int)time(NULL));
	vector<int> v;
	for(int i = 0 ; i < 10;i++){
		v.push_back(i);
	}
	//打乱顺序
	random_shuffle(v.begin(), v.end());
}
merge
  • 两个容器合并，并且存储在另一个容器中
  • 函数原型：
  • merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
    • 两个容器合并，这两个容器必须是有序的，而且都是升序或者降序，不能一升一降
    • 合并之后，会自动排序，升序
    • 参数就是，第一个容器的迭代器，第二个容器的迭代器，最后放在的容器的开始迭代器
    • beg1 开始的迭代器
    • end1 结束的迭代器
    • beg2 开始的迭代器
    • end2 结束的迭代器
    • dest 目标容器的开始迭代器
void test01(){
    //这两个容器必须都是相同的顺序
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10 ; i++) {
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	vector<int> vtarget;
	//目标容器需要提前开辟空间
	vtarget.resize(v1.size() + v2.size());
	//合并  需要两个有序序列
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
    //合并之后，自动排序，升序
}
reverse
  • 将容器内元素进行反转
  • 函数原型：
  • reverse(iterator beg, iterator end);
    • 将指定容器内的元素反回来存储
    • beg 开始的迭代器
    • end 结束的迭代器
void test01(){
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(40);
    //反转后
	reverse(v.begin(), v.end());
}

常用拷贝和替换算法

copy
  • 容器内指定范围的元素拷贝到另一个容器中
  • 函数原型：
  • copy(iterator beg, iterator end, iterator dest);
    • 拷贝，一般不适用这个，因为这其实就是个赋值
    • beg 开始迭代器
    • end 结束迭代器
    • dest 目标起始迭代器
void test01(){
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i + 1);
	}
	vector<int> v2;
    //需要提前resize
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());
}
replace
  • 将容器内指定范围内的旧元素修改为新元素
  • 函数原型：
  • replace(iterator beg, iterator end, oldvalue, newvalue);
    • 将区间内的旧元素替换成新元素，如果有多个旧元素，那么就全部替换
    • beg 开始的迭代器
    • end 结束的迭代器
    • oldvalue 旧元素
    • newvalue 新元素
void test01(){
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(20);
	//将容器中的20 替换成 2000
	cout << "替换后：" << endl;
	replace(v.begin(), v.end(), 20,2000);
}
replace_if
  • 将区间内满足条件的元素，替换成指定元素
  • 函数原型：
  • replace_if(iterator beg, iterator end, _pred, newvalue);
    • 按照条件替换元素，使用谓词
    • beg 开始的迭代器
    • end 结束的迭代器
    • _pred 谓词
    • newvalue 替换的新元素
class ReplaceGreater30{    //一元谓词
public:
	bool operator()(int val){
		return val >= 30;
	}
};
void test01(){
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	//将容器中大于等于的30 替换成 3000
	cout << "替换后：" << endl;
	replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
}
swap
  • 互换两个容器的元素
  • 函数原型：
  • swap(container c1, container c2);
    • 互换两个容器的元素
    • c1 第一个容器
    • c2 第二个容器
void test01(){
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+100);
	}
	cout << "交换后： " << endl;
	swap(v1, v2);
}

常用算术生成算法

  • 需要包含头文件#include <numeric>
accumulate
  • 计算区间内容器元素的累计总和
  • 函数原型：
  • accumulate(iterator beg, iterator end, value);
    • 计算容器内的元素总和
    • beg 开始的迭代器
    • end 结束的迭代器
    • value 起始值
void test01(){
	vector<int> v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}
    //如果不用这个起始值，就设置成0
	int total = accumulate(v.begin(), v.end(), 0);
	cout << "total = " << total << endl;
}
fill
  • 向容器中填充指定的元素
  • 函数原型：
  • fill(iterator beg, iterator end, value);
    • 向指定的范围内填充value
    • beg 开始的迭代器
    • end 结束的迭代器
    • value 填充的值
void test01(){
	vector<int> v;
    //刚开始resize，容器里面都是0
	v.resize(10);
	//填充100,这样容器中是10个100
	fill(v.begin(), v.end(), 100);
}

常用集合算法

set_intersection
  • 求两个容器的交集
  • 函数原型：
  • set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
    • 求两个集合的交集，并将交集的元素放到指定的容器中
    • 两个容器必须是有序的序列
    • 返回值是指定的交集容器中存放数据的最后一个位置的迭代器
    • beg1 容器1的开始迭代器
    • end1 容器1的结束迭代器
    • beg2 容器2的开始迭代器
    • end2 容器2的结束迭代器
    • dest 目标容器的开始迭代器
class myPrint{
public:
	void operator()(int val){
		cout << val << " ";
	}
};
void test01(){
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
		v2.push_back(i+5);
	}
	vector<int> vTarget;
	//取两个里面较小的值给目标容器开辟空间
	vTarget.resize(min(v1.size(), v2.size()));
	//返回目标容器的最后一个元素的迭代器地址
	vector<int>::iterator itEnd = 
        set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	//如果遍历的结束迭代器使用的是vTarget.end()
    //那么就会出现就会打印后面多一串0
	for_each(vTarget.begin(), itEnd, myPrint());
}
set_union
  • 求两个集合的并集
  • 函数原型：
  • set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
    • 求两个集合的并集，跟上面求交集一样
    • 必须是两个有序的序列
class myPrint{
public:
	void operator()(int val){
		cout << val << " ";
	}
};
void test01(){
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}
	vector<int> vTarget;
	//取两个容器的和给目标容器开辟空间
	vTarget.resize(v1.size() + v2.size());
	//返回目标容器的最后一个元素的迭代器地址
	vector<int>::iterator itEnd = 
        set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	//跟求交集一样，如果不用itEnd就多打印一串0
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}
set_difference
  • 求两个集合的差集
  • 函数原型：
  • set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
    • 两个集合必须是有序序列
    • 求集合差集，v1和v2的差集，就是v1中有而v2中没有的元素；v2和v1的差集，就是v2中有而v1中没有的元素
    • beg1 容器1开始的迭代器
    • end1 容器1结束的迭代器
    • beg2 容器2开始的迭代器
    • end2 容器2结束的迭代器
    • dest 目标容器开始的迭代器
void test01(){
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}
	vector<int> vTarget;
	//取两个里面较大的值给目标容器开辟空间
	vTarget.resize( max(v1.size() , v2.size()));
    
	//返回目标容器的最后一个元素的迭代器地址
	cout << "v1与v2的差集为： " << endl;
	vector<int>::iterator itEnd = 
        set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
	cout << "v2与v1的差集为： " << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    //如果遍历之后，依然跟上面求交集和并集一样
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值