第十节 STL-常用算法

最新推荐文章于 2023-12-24 17:06:26 发布
最新推荐文章于 2023-12-24 17:06:26 发布
阅读量362 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50290335/article/details/125505162
版权

概述：

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

1 常用遍历算法

学习目标：掌握常用的遍历算法

算法简介：

for_each        //遍历容器
transform       //搬运容器到另一个容器中

1.1 for_each

功能描述：实现遍历容器

函数原型：

for_each(iterator beg,iterator end,_func);
//遍历算法 遍历容器元素
//beg开始迭代器
//end结束迭代器
//_func函数或者函数对象
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>

using namespace std;
//普通函数
void print01(int val)
{
	cout << val << " ";
}

//函数对象
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v;

	v.push_back(10); 
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//遍历算法
	for_each(v.begin(), v.end(),print01);
	cout << endl;
	for_each(v.begin(), v.end(), print02());
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：for_each是在实际开发中最常用的遍历算法，需要熟练掌握

1.2 transform

功能描述：搬运容器到另一个容器中

函数原型：

transform(iterator beg1,iterator end1,iterator beg2,_func);
//beg1  源容器开始迭代器
//endl  源容器结束迭代器
//beg2  目标容器开始迭代器
//_func  函数或者函数对象（取出的对象进行处理后再放进目标容器中）
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>

using namespace std;

class Transform
{
public:
	int operator()(int val)
	{
		//将值搬运到目标容器中，当然也可以进行运算后进行搬运，例如return val+100；
		return val;
	}
};

class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v;

	v.push_back(10); 
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	vector<int> v2;
	//还需要对目标空间进行开辟，因为塞不进去，这样会会报错
	v2.resize(v.size());
	//搬运
	transform(v.begin(), v.end(), v2.begin(), Transform());
	//遍历
	for_each(v2.begin(),v2.end(),MyPrint());
	cout << endl;

	//仿函数是可以直接使用的，但是需要创建一个对象
	Transform tr;
	cout << tr(2) << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：搬运的目标容器必须要提前开辟空间，否则无法正常搬运

2 常用查找算法

学习目标：掌握常用的查找算法

算法简介：

find                    //查找元素
find_if                 //按条件查找元素
adjacent_find           //查找相邻重复元素
binary_search           //二分查找法
count                   //统计元素个数
count_if                //按条件统计元素个数

2.1 find

功能描述：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

find(iterator beg,iterator end,value)
//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg开始迭代器
//end结束迭代器
//value查找的元素
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>

using namespace std;

//查找内置的数据类型
void test01()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	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;
	}
	//不重载==运算符，就无法判断Person类对象是否相等
	bool operator==(const Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			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);

	Person pp("aaa",10);

	vector<Person>::iterator it = find(v.begin(), v.end(), pp);
	if (it == v.end())		//我们可以想像一下，两个Peroson对象怎么才能判断两个相同或者不相同呢，所以需要重载==运算符
	{
		cout << "未找到元素" << endl;
	}
	else
	{
		cout << "找到元素 姓名：" << (*it).m_Name << "年龄：" << (*it).m_Age << endl;
	}
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：find可以再容器中找到指定的元素，返回值是迭代器

2.2 find_if

功能描述：按条件查找元素

函数原型：

find_if(iterator beg,iterator end,_Pred)
//按仿函数查找元素，找到返回指定位置迭代器，找不到返回结束迭代器
//beg开始迭代器
//end结束迭代器
//_Pred函数或者谓词（返回bool类型的仿函数）
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

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);
	}
	vector<int>::iterator pos = v.begin();
	//找到大于5的数
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		if (pos != v.end())
		{
			//find_if为条件查找，find为值查找
			pos = find_if(pos, v.end(), GreaterFive());
			cout << *pos << endl;
			pos++;
		}
		else
		{
			return;
		}
	}
}


class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//不重载==运算符，就无法判断Person类对象是否相等
	bool operator==(const Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	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())		//我们可以想像一下，两个Peroson对象怎么才能判断两个相同或者不相同呢，所以需要重载==运算符
	{
		cout << "未找到元素" << endl;
	}
	else
	{
		cout << "找到元素 姓名：" << (*it).m_Name << "年龄：" << (*it).m_Age << endl;
	}
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

总结：find_if的返回的是迭代器

2.3 adjacent_find

功能描述：查找相邻重复元素

函数原型：

adjacent_find(iterator beg,iterator end)
//查找相邻重复元素，返回相邻元素的第一个位置的迭代器
//beg开始迭代器
//end结束迭代器
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

void test01()
{
	vector<int> v;

	v.push_back(0);
	v.push_back(1);
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);

	//查找相邻元素算法，找到返回相邻第一个的迭代器，否则返回结束迭代器
	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
	if (pos == v.end())
	{
		cout << "未找到相邻元素" << endl;
	}
	else
	{
		cout << "找到相邻元素" <<  *pos << endl;
	}

}

int main()
{
	test01();

	system("pause");
	return 0;
}

2.4 binary_search

功能描述：查找指定元素是否存在

函数原型：

bool binary_search(iterator beg,iterator end,value);
//查找指定的元素，查到返回true，否则false
//注意：在无序序列中不适用
//beg开始迭代器
//end迭代器
//value查找的元素
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

void test01()
{
	vector<int> v;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	//二分查找法，只能是有序序列
	bool ret = binary_search(v.begin(), v.end(),7);
	if (ret)
	{
		cout << "找到元素" << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

}

int main()
{
	test01();

	system("pause");
	return 0;
}

2.5 count

功能描述：统计元素个数

函数原理：

int count(iterator beg,iterator end,value)
//统计元素出现次数
//beg开始迭代器
//end结束迭代器
//value统计的元素
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//查找内置的数据类型
void test01()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	int num = count(v.begin(), v.end(), 2);
	cout << "元素的个数为：" << num << endl;
}


class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//不重载==运算符，就无法判断Person类对象年龄是否相等
	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("张飞", 30);
	Person p2("关羽", 30);
	Person p3("刘备", 30);
	Person p4("曹操", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	Person p("诸葛亮", 30);
	
	int num = count(v.begin(), v.end(), p);
	cout << "和诸葛亮同岁的人数为：" << num << endl;
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

总结：统计自定义的数据类型个数，需要重载==号

2.6 count_if

功能描述：按条件统计元素个数

函数原型：

int count_if(iterator beg,iterator end,_Pred)
//统计元素出现次数
//beg开始迭代器
//end结束迭代器
//_Pred谓词
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

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);
	}

	//找到大于5的数
	int num = count_if(v.begin(),v.end(), GreaterFive());
	cout << "大于5的个数为：" << 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 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);

	//找年龄大于20的人的个数
	int num = count_if(v.begin(), v.end(), Greater20());
	cout << "年龄大于20的个数为：" << num << endl;
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

3 常用排序算法

学习目标：掌握常用的排序算法

算法简介：

sort                //对容器内的元素进行排序
random_shuffle      //洗牌 指定范围内的元素随机调整次序
merge               //容器元素合并，并存储到另一个容器中
reverse             //反转指定范围的元素

3.1 sort

功能描述：对容器内元素进行排序

函数原理：

sort(iterator beg,iterator end,_Pred);
//按值查找元素，找到返回指定位置的迭代器，找不到返回迭代器结束位置
//beg开始迭代器
//end结束迭代器
//_Pred谓词，不写从小到大排序
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v;

	v.push_back(10);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);

	//默认排序从小到大
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), MyPrint);
	cout << endl;

	//改变排序规则，从大到小
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.2 random_shuffle

功能描述：洗牌 指定范围内的元素随机调整次序

函数原型：

random_shuffle(iterator beg,iterator end);
//指定范围内的元素随机调整次序
//beg开始迭代器
//end结束迭代器

#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	//洗牌算法，打乱次序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(),v.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：random_shuffle洗牌算法比较实用，实用时记得加随机数种子

3.3 merge

功能描述：两个容器元素合并，并存储到另一个容器中

函数原型：

merge(iterator beg1,iterator end1,iterator beg2,iterator end1,iterator dest)
//容器元素合并，并存储到另一个容器中
//注意:两个容器必须是有序的
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end2 容器2结束迭代器
//dest 目标容器开始迭代器
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(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+1);
	}
	//目标容器
	vector<int> vTarger;

	//目标容器必须开辟空间才能放进去数据
	vTarger.resize(v1.size()+v2.size());

	//合并算法，两个容器必须是有序序列才可以合并
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarger.begin());
	for_each(vTarger.begin(), vTarger.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.4 reverse

功能描述：将容器内的元素进行反转

函数原型：

reverse(iterator beg,iterator end)
//反转指定范围的元素
//beg开始迭代器
//end结束迭代器
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	//反转算法
	reverse(v1.begin(),v1.end());
	for_each(v1.begin(), v1.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：reverse反转区间内元素，面试题可能涉及到

4 常用的拷贝和替换算法

学习目标：掌握常用的拷贝和替换算法

算法简介：

copy            //容器内指定范围的元素拷贝到另一个容器中
replace         //将容器内指定范围的旧元素修改为新元素
replace_if      //容器内指定范围满足条件的元素替换为新元素
swap            //互换两个容器的元素

4.1 copy

功能描述：容器内指定范围的元素拷贝到另一个容器中

函数原型：

copy(iterator beg,iterator end,iterator dest)
//将一个容器里面的元素拷贝到另一个容器中
//beg开始迭代器
//end结束迭代器
//dest目标起始迭代器
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	//copy算法
	vector<int> v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());
	for_each(v2.begin(),v2.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结:copy算法的目标容器需要提前开辟空间

4.2 replace

功能描述：将容器内指定范围的旧元素改为新元素

函数原型：

replace(iterator beg,iterator end,oldvalue,newvalue)
//将区间内旧元素替换为新元素
//beg开始迭代器
//end结束迭代器
//oldvalue旧元素
//newvalue新元素
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v1;

	v1.push_back(100);
	v1.push_back(10);
	v1.push_back(100);
	v1.push_back(10);
	v1.push_back(100);

	//replace算法
	//将容器里面的100替换为10
	replace(v1.begin(), v1.end(), 100, 10);
	for_each(v1.begin(),v1.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.3 replace_if

功能描述：将区间内满足条件的元素，替换成指定元素

函数原型：

replace_if(iterator beg,iterator end,_Pred,newvalue)
//按条件替换元素，满足条件的替换成指定元素
//beg开始迭代器
//end结束迭代器
//_Pred谓词
//newvalue替换的新元素
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

//仿函数
class Greater10
{
public:
	bool operator()(int val)
	{
		return val > 10;
	}
};


void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v1;

	v1.push_back(100);
	v1.push_back(10);
	v1.push_back(100);
	v1.push_back(10);
	v1.push_back(100);

	//replace_if算法
	//将容器里面的大于10的数替换为10
	replace_if(v1.begin(), v1.end(), Greater10(), 10);
	for_each(v1.begin(),v1.end(),MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：replace_if按条件查找，可以利用仿函数灵活筛选满足的条件

4.4 swap

功能描述：互换两个容器的元素

函数原型;

swap(container c1,container c2);
//互换两个容器的元素
//c1容器1
//c2容器2
#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

//查找内置的数据类型
void test01()
{
	vector<int> v1;

	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);

	vector<int> v2;

	v2.push_back(20);
	v2.push_back(20);
	v2.push_back(20);
	v2.push_back(20);
	v2.push_back(20);

	//swap算法
	swap(v1,v2);

	for_each(v1.begin(),v1.end(),MyPrint);
	cout << endl;
	for_each(v2.begin(), v2.end(), MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

5 常用算术生成算法

学习目标：掌握常用的算术生成算法

注意：算术生成算法属于小型算法，使用时包含的头文件为#include<numeric>

算法简介：

accumluate       //计算容器元素累计总和
fill             //向容器中添加元素

5.1 accumulate

功能描述：计算区间内容器元素累计总和

函数原型：

accumulate(iterator beg,iterator end,value)
//计算容器元素的累计和
//beg开始迭代器
//end结束迭代器
//value起始值
#include<iostream>
#include<string>
#include<vector>
#include<numeric>

using namespace std;

void test01()
{
	vector<int> v1;

	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);
	v1.push_back(10);

	//accumulate算法
	//第三个参数时元素总和再加上的值
	int total = accumulate(v1.begin(), v1.end(), 0);
	cout << total << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

5.2 fill

功能描述：想容器中填充指定的元素

函数原型：

fill(iterator beg,iterator end,value)
//向容器中填充元素
//beg开始迭代器
//end结束迭代器
//value填充的值
#include<iostream>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>

using namespace std;

void MyPrint(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v1;

	//现在容器里面的数据都是0
	v1.resize(10);

	//fill算法
	//后期重新填充数据
	fill(v1.begin(), v1.end(), 100);
	for_each(v1.begin(), v1.end(), MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

6 常用集合算法

学习目标：掌握常用的集合算法

算法简介：

set_intersection        //求两个容器的交集
set_union               //求两个容器的并集
set_difference          //求两个容器的差集

6.1 set_intersection

功能描述：求两人容器的交集

函数原型：

set_intersection<iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest>
//求两个容器的交集
//注意：两个集合必须是有序序列
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end2 容器2结束迭代器
//dest 目标容器开始迭代器
#include<iostream>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>

using namespace std;

void MyPrint(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);
	}

	//set_intersection算法
	//获取交集，这个算法会返回最后一个交集的迭代器
	vector<int> vTarget;
	//开辟空间，开辟v1和v2之间小的空间大小，虽然可能还是太多了（被0填充），但是我们有最后一个交集的迭代器
	vTarget.resize(min(v1.size(),v2.size()));
	vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

  • 求交集的两个集合必须是有序序列
  • 目标容器开辟空间需要从两个容器中取小值
  • set_intersection返回值即是交集中最后一个元素的位置

6.2 set_union

功能描述：求两个集合和并集

函数原理：

set_union<iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest>
//求两个容器的并集
//注意：两个集合必须是有序序列
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end2 容器2结束迭代器
//dest 目标容器开始迭代器
#include<iostream>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>

using namespace std;

void MyPrint(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);
	}

	//set_union算法
	//获取并集，这个算法会返回最后一个并集的迭代器
	vector<int> vTarget;
	//开辟空间，开辟v1加上v2的大小空间
	vTarget.resize(v1.size()+v2.size());
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

6.3 set_difference

功能描述：求两个集合的差集

函数原型：

set_difference<iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest>
//求两个容器的差集
//注意：两个集合必须是有序序列
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end2 容器2结束迭代器
//dest 目标容器开始迭代器
#include<iostream>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>

using namespace std;

void MyPrint(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);
	}

	//set_difference算法
	//获取差集，这个算法会返回最后一个差集的迭代器
	vector<int> vTarget;
	//开辟空间，开辟最大的一个空间即可
	vTarget.resize(max(v1.size(),v2.size()));
	vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	cout << "v1和v2的差集为：" << endl;
	for_each(vTarget.begin(), itEnd, MyPrint);
	cout << endl;

	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
	cout << "v2和v1的差集为：" << endl;
	for_each(vTarget.begin(), itEnd, MyPrint);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结:

  • 求差集的两个集合必须为有序序列
  • 目标容器开辟空间需要从两个容器取较大值
  • set_difference返回值既是差集最后一个元素的位置
光屁股的雨果
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
第10章 跳表和散列 10.1 字典 10.2 抽象数据类型 10.3 线性表描述 10.4 跳表表示（可选） 10.4.1 理想情况 10.4.2 插入和删除 10.4.3 级的分配 10.4.4 结构skipNode 10.4.5 类skipList 10.4.6 skipList方法的复杂度 ...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
《计算机世界》报组织的“世纪评选”把他评为我国“20世纪最有影响的IT人物”10个人之一（排在第2位）。他的功绩是把千百万群众带入计算机的大门。 1 C语言概述 1.1 Ｃ语言的发展过程 1.2 当代最优秀的程序设计语言 ...
多孔材料孔隙率、孔径分布计算程序
04-28
多孔材料孔隙率、孔径分布计算程序
STL常见算法总结
sinat_31608641的博客
11-19 4013
一、各种常见算法的用法 accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一
STL常用算法
qq_24472227的博客
06-06 1053
1、常用遍历算法 2、常用查找算法 3、常用排序算法 4、常用拷贝和替换算法 5、常用算术生成算法 6、常用集合算法
C++之STL常用算法
C_xxy's blog
08-29 844
一、写前概述： C++中：继承机制支持派生类重用基类的代码；多态机制使得一个继承层次中的所有派生类可以重用在抽象基类中定义的纯虚函数接口；标准模板库（Standard Template Library,STL）使得可以重用函数定义或类定义来处理不同类型的数据结构。STL主要包括三个部分：①容器（包含对象的对象）、②迭代器（相当于指向元素对象的指针）、③算法（一些能在各种容器中通用的标准算法...
STL中常用的算法
蓬莱道人的博客
03-05 968
为了处理容器内的元素，STL提供了一些标准算法，包括查找、排序、拷贝、重新排序、修改、数值运算等基本而普遍的算法。算法并非容器内的成员函数，而是一种搭配迭代器使用的全局函数。这么做有一个重要的优势，所有算法只需要实现一份，就可以对所有容器运作，不必为每一种容器量身定做。 1、非更易型算法 2、更易型算法 3、移除型算法 4、变序型算法 5、排序算法 6、已排序区间算法 7、数...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
《计算机世界》报组织的“世纪评选”把他评为我国“20世纪最有影响的IT人物”10个人之一（排在第2位）。他的功绩是把千百万群众带入计算机的大门。 1 C语言概述 1.1 Ｃ语言的发展过程 1.2 当代最优秀的程序设计语言 ...
Visual C++开发经验技巧宝典（第1章）
09-04
0074　STL算法的优点　31 0075　如何设计和使用STL迭代器　31 0076　使用STL需要包含哪些头文件　32 0077　STL简单应用　32 1.10　C++.NET语法　33 0078　在C++.NET中如何判断空指针　33 0079　C++与C++.NET中纯虚...
STL【算法】| 常用算法大集合
weixin_45926547的博客
03-08 1656
文章目录一、简介1.1 类别1.1.1 _if结尾1.1.2 _copy尾词1.1.3 算法类别二、非变动性算法2.1 简介2.2 常见算法2.2.1 元素计数2.2.2 最大值和最小值2.2.3 搜寻元素三、变动性算法3.1 简介3.2 常用3.3 移除性算法四、变序性算法五、排序算法六、已序区间算法七、数值算法 一、简介 STL算法都被设计用来处理一个或多个迭代器区间；多数情况下只需提供起点即可； STL算法采用覆盖模式而非安插模式； 1.1 类别 1.1.1 _if结尾 当此类算法有两种形式
STL常用算法简介
11-14
STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介
STL常用算法大全
12-02
STL常用算法大全
C++ stl算法汇总(C++程序员必备)
02-08
C++ stl算法汇总 STL 各种算法 应用 大全
STL和常用算法简介
07-09
STL和常用算法简介
C++STL常用算法(超详细!)
最新发布
qq_62855390的博客
12-24 1508
v1中是有4的,但是它结果显示为未找到,就是因为v1是无序的。，找到返回相邻元素的第一个位置的迭代器,找不到返回结束迭代器。，找到返回指定元素的迭代器，找不到返回结束迭代器end（），找到返回指定元素的迭代器，找不到返回结束迭代器end（）注:两个容器必须是有序的,合并完之后也是一个有序序列。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器包小容器。返回值:并集中最后一个元素的迭代器位置。
stl常用算法总结
Cristiano_san的博客
10-26 998
stl的算法简单概念 算法（algorithm）是用模板技术实现的适用于各种容器的通用程序。算法常常通过迭代器间接地操作容器元素，而且通常会返回迭代器作为算法运算的结果。 STL大约提供了70个算法，每个算法都是一个模板函数或者一组模板函数，能够在许多不同类型的容器上进行操作，各个容器则可能包含着不同类型的数据元素。STL中的算法覆盖了在容器上实施的各种常见操作，如遍历、排序、检索、插入及删除元素等操作 1、find/count算法 find用于查找指定数据在某个区间中是否存在，该函数返回等于指定值的第一个
详解c++STL—STL常用算法
怀秋秋意的博客
05-22 907
详解c++STL—STL常用算法
c++---STL常用算法
m0_50046535的博客
04-25 3266
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
加载STL-10数据集
04-06
STL-10数据集是一个包含10个类别的图像数据集，包括飞机、鸟、汽车、猫、鹿、狗、青蛙、马、船和卡车。每个类别包含5000张32x32的彩色图像，其中500张用于训练，100张用于验证，剩余的用于测试。 在本教程中，我们将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值