STL常用算法总结（下）

最新推荐文章于 2024-11-09 20:38:27 发布

ekkoxxxx

最新推荐文章于 2024-11-09 20:38:27 发布

阅读量230

点赞数 1

文章标签：算法 c++

本文链接：https://blog.csdn.net/cslx97/article/details/123159443

版权

本文介绍了C++中数值算法（如accumulate, inner_product等）、异变算法（如fill, generate等）以及关系和集合算法（如equal, set_intersection等）。通过实例展示了如何使用这些算法操作整型向量，实现基本的数学运算、数据修改和比较分析。

摘要由CSDN通过智能技术生成

5.数值算法
包含在头文件中，进行数值运算。

#include <iostream>
#include <vector>
#include <numeric> // 数值算法
#include <iterator> // 定义了ostream_iterator

using namespace std;

int main(int argc, char* argv[])
{
	int arr[] = { 1, 2, 3, 4, 5 };
	vector<int> vec(arr, arr + 5);
	vector<int> vec2(arr, arr + 5);

	//  accumulate: iterator对标识的序列段元素之和，加到一个由val指定的初始值上。
	int temp;
	int val = 0;
	temp = accumulate(vec.begin(), vec.end(), val);
	cout << "accumulate(val = 0): " << temp << endl;
	val = 1;
	temp = accumulate(vec.begin(), vec.end(), val);
	cout << "accumulate(val = 1): " << temp << endl;

	// inner_product: 对两个序列做内积(对应元素相乘，再求和)并将内积加到一个输入的初始值上。
	// 这里是：1*1 + 2*2 + 3*3 + 4*4 + 5*5
	val = 0;
	temp = inner_product(vec.begin(), vec.end(), vec2.begin(), val);
	cout << "inner_product(val = 0): " << temp << endl;

	// partial_sum: 创建一个新序列，其中每个元素值代表指定范围内该位置前所有元素之和。
	// 第一次，1   第二次，1+2  第三次，1+2+3  第四次，1+2+3+4
	ostream_iterator<int> oit(cout, " "); // 迭代器绑定到cout上作为输出使用
	cout << "ostream_iterator: ";
	partial_sum(vec.begin(), vec.end(), oit);// 依次输出前n个数的和
	cout << endl;
	// 第一次，1   第二次，1-2  第三次，1-2-3  第四次，1-2-3-4
	cout << "ostream_iterator(minus): ";
	partial_sum(vec.begin(), vec.end(), oit, minus<int>());// 依次输出第一个数减去（除第一个数外到当前数的和）
	cout << endl;

	// adjacent_difference: 创建一个新序列，新序列中每个新值代表当前元素与上一个元素的差。
	// 第一次，1-0   第二次，2-1  第三次，3-2  第四次，4-3
	cout << "adjacent_difference: ";
	adjacent_difference(vec.begin(), vec.end(), oit); // 输出相邻元素差值 后面-前面
	cout << endl;
	// 第一次，1+0   第二次，2+1  第三次，3+2  第四次，4+3
	cout << "adjacent_difference(plus): ";
	adjacent_difference(vec.begin(), vec.end(), oit, plus<int>()); // 输出相邻元素差值 后面-前面 
	cout << endl;

	return 0;
}

在这里插入图片描述
6.异变算法
包含在头文件中，是改变数值的算法。

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

using namespace std;

template <class T>
struct display
{
	void operator()(const T&x) const
	{
		cout << x << " ";
	}
};
//  作用类似于上面结构体，只不过只能显示int类型的数据
void printElem(int& elem)
{
	cout << elem << " ";
}

template<class T>
struct plus2
{
	void operator()(T&x)const
	{
		x += 2;
	}

};

class even_by_two
{
private:
	static int _x; //  注意静态变量   
public:
	int operator()()const
	{
		return _x += 2;
	}
};
int even_by_two::_x = 0; //  初始化静态变量

int main(int argc, char* argv[])
{
	int iarr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
	vector<int> iv(iarr, iarr + sizeof(iarr) / sizeof(int));

	/*** fill: 将输入值赋给标志范围内的所有元素。 ***/
	//  原型： void fill(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)  
	fill(iv.begin(), iv.end(),5);
	cout << "fill: ";
	for_each(iv.begin(), iv.end(), display<int>());
	cout << endl;

	/*** fill_n: 将输入值赋给first到first+n范围内的所有元素。 ***/
	//  原型： _OutIt fill_n(_OutIt _Dest, _Diff _Count, const _Ty& _Val)
	fill_n(iv.begin(), 4, 3); //  赋4个3给iv 
	cout << "fill_n: ";
	for_each(iv.begin(), iv.end(), display<int>());
	cout << endl;

	/*** for_each: 用指定函数依次对指定范围内所有元素进行迭代访问，返回所指定的函数类型。 ***/
	//  原型： _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
	for_each(iv.begin(), iv.end(), plus2<int>()); //  每个元素+2
	cout << "for_each: ";
	for_each(iv.begin(), iv.end(), printElem); //  输出
	cout << endl;

	/*** generate: 连续调用输入的函数来填充指定的范围。 ***/
	//  原型： void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
	//  使用even_by_two()函数返回的值，来填充容器iv
	generate(iv.begin(), iv.end(), even_by_two());
	cout << "generate: ";
	for_each(iv.begin(), iv.end(), display<int>());
	cout << endl;

	/*** generate_n: 与generate函数类似，填充从指定iterator开始的n个元素。 ***/
	//  原型： _OutIt generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
	//  使用even_by_two()函数返回的值，来填充容器iv的前三个值
	generate_n(iv.begin(), 3, even_by_two());
	cout << "generate_n: ";
	for_each(iv.begin(), iv.end(), display<int>()); //  由于_X是static 所以接着 增长
	cout << endl;

	/*** transform: 将输入的操作作用与指定范围内的每个元素，并产生一个新的序列。 ***/
	//  原型： _OutIt transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
	// 容器的所有值全部减2
	transform(iv.begin(), iv.end(), iv.begin(), bind2nd(minus<int>(), 2));
	cout << "transform: ";
	for_each(iv.begin(), iv.end(), display<int>()); //  由于_X是static 所以接着 增长
	cout << endl;

	return 0;
}

在这里插入图片描述
7.关系算法
包含在头文件中，比较、判断数值的关系。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(int argc, char* argv[])
{
	int iarr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	vector<int> iv1(iarr, iarr + 5);
	vector<int> iv2(iarr, iarr + 9);

	//  equal: 如果两个序列在标志范围内元素都相等，返回true。
	cout <<"equal: " << equal(iv1.begin(), iv1.end(), iv2.begin()) << endl;//  1 表示相等，因为只比较跟 iv1长度大小的数组      

	// includes: 判断第一个指定范围内的所有元素是否都被第二个范围包含，使用底层元素的<操作符，成功返回true。
	// 判断判断iv2中元素是否都出现在iv1中
	cout << "includes: " << includes(iv1.begin(), iv1.end(), iv2.begin(), iv2.end()) << endl;

	// max: 返回两个元素中较大一个。
	cout << "max: " << max(iv1[0],iv1[1]) << endl;
	// min: 返回两个元素中较小一个。
	cout << "min: " << min(iv1[0], iv1[1]) << endl;

	// max_element: 返回一个ForwardIterator，指出序列中最大的元素。
	cout << "max_element: " << *max_element(iv1.begin(), iv1.end()) << endl;
	// min_element: 返回一个ForwardIterator，指出序列中最小的元素。
	cout << "min_element: " << *min_element(iv1.begin(), iv1.end()) << endl;

	//  mismatch: 并行比较两个序列，指出第一个不匹配的位置，返回一对iterator，标志第一个不匹配元素位置。如果都匹配，返回每个容器的last。
	pair<vector<int>::iterator, vector<int>::iterator> pa;
	pa = mismatch(iv1.begin(), iv1.end(), iv2.begin());
	if (pa.first == iv1.end()) //  true 表示相等，因为只比较跟iv1长度大小的数组 
		cout << "第一个向量与第二个向量匹配" << endl;
	else
	{
		cout << "两个向量不同点--第一个向量点:" << *(pa.first) << endl; // 这样写很危险，应该判断是否到达end   
		cout << "两个向量不同点--第二个向量点:" << *(pa.second) << endl;
	}

	return 0;
}

在这里插入图片描述
8.集合算法
包含在头文件中，研究两集合之间的关系的算法。

#include <iostream>
#include <set>
#include <algorithm>
#include <iterator> 

using namespace std;

template <class T>
struct display
{
	void operator()(const T&x) const
	{
		cout << x << " ";
	}
};

int main(int argc, char* argv[])
{
	int iarr1[] = { 1, 3, 5, 7, 9, 11 };
	int iarr2[] = { 1, 1, 2, 3, 5, 8, 13 };

	multiset<int> s1(iarr1, iarr1 + 6);
	multiset<int> s2(iarr2, iarr2 + 7);
	cout << "s1: ";
	for_each(s1.begin(), s1.end(), display<int>());
	cout << endl;
	cout << "s2: ";
	for_each(s2.begin(), s2.end(), display<int>());
	cout << endl;

	/*** set_union: 构造一个有序序列，包含两个序列中所有的不重复元素。 ***/
	//  原型： _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
	cout << "union of s1 and s2: ";
	// 两个集合合并，相同元素个数取 max(m,n)。   
	set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
	cout << endl;

	/*** set_intersection: 构造一个有序序列，其中元素在两个序列中都存在。 ***/
	//  原型： _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
	cout << "Intersection of s1 and s2: ";
	// 两个集合交集，相同元素个数取 min(m,n).  
	set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
	cout << endl;

	/*** set_difference: 构造一个有序序列，该序列仅保留第一个序列中存在的而第二个中不存在的元素。 ***/
	//  原型： _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
	cout << "Intersection of s1 and s2: ";
	// 两个集合差集 就是去掉S1中 的s2   
	set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
	cout << endl;

	/*** set_symmetric_difference: 构造一个有序序列，该序列取两个序列的对称差集(并集-交集)。 ***/
	//  原型： _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
	cout << "Intersection of s1 and s2: ";
	// 两个集合对称差集：就是取两个集合互相没有的元素 。两个排序区间，元素相等指针后移，不等输出小的并前进   
	// 相同元素的个数 abs(m-n)   
	set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
	cout << endl;

	return 0;
}