STL之数值算法

一、简介

STL 的数值算法(Numeric algorithms)是一组对容器元素进行数值计算的模板函数，包括容器元素求和 accumulate 、两序列元素的内积 inner_product 、容器元素的一系列部分元素和 partial_sum 、容器每对相邻元素的差adjacent_difference等函数。本节介绍的算法，必须包含#include<numeric>文件。

二、实例

先观察如何使用

#include<iostream>
#include<numeric>
#include<vector>
#include<algorithm>
#include<functional>
#include<iterator>
using namespace std;

int main() {

	int ia[5] = { 1,2,3,4,5 };
	vector<int> iv(ia, ia + 5);

	cout << accumulate(iv.begin(), iv.end(), 0) << endl;
	cout << accumulate(iv.begin(), iv.end(), 0, minus<int>()) << endl;

	cout << inner_product(iv.begin(), iv.end(), iv.begin(), 10) << endl;
	cout << inner_product(iv.begin(), iv.end(), iv.begin(), 10, minus<int>(), plus<int>()) << endl;


	//把迭代器绑定到cout上，作为输出用
	ostream_iterator<int> oite(cout, " ");

	partial_sum(iv.begin(), iv.end(), oite);
	cout << endl;
	partial_sum(iv.begin(), iv.end(), oite, minus<int>());
	cout << endl;

	adjacent_difference(iv.begin(), iv.end(), oite);
	cout << endl;
	adjacent_difference(iv.begin(), iv.end(), oite, plus<int>());
	cout << endl;
        return 0;
	}

三、具体的算法

1、accumulate

/*
*	函数名：	accumulate
*	功能：    将指定区间内的元素累加
*/
// 版本1，算法缺省行为
template <class InputIterator,class T>
T accumulate(InputIterator first, InputIterator last, T init)
{
	for (; first != last; first++)
	{
		init = init + *first;	
	}
	return init;
}
 
// 版本2，接收外界传入一个仿函数
template <class InputIterator,class T,class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op)
{
	for (; first != last; first++)
	{
		init = binary_op(init, *first);
	}
	return init;
}

2、adjacent_differencee（计算相邻元素的差额）

/*
*	函数名：	adjacent_differencee
*	功能：	计算[first,last)中相邻元素的差额，首元素内容不变
*	说明：	与partial_sum互为逆运算
*/
// 版本1，算法缺省行为
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result)
{
	if (first == last)
	{
		return result;	// 区间内容为空直接返回result
	}
	*result = *first;	// 首先记录第一个元素(即原容器中第一个元素内容不变)
	iterator_traits<InputIterator>::value_type value = *first;
	while (++first != last)	// 之后的元素为本位置-前一个位置的值
	{
		T tmp = *first;
		*++first = tmp - value;
		value = tmp;
	}
	return ++result;
}
 
// 版本2，接收外界传入一个仿函数
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator adjacent_difference(InputIterator first, InputIterator last, 
									OutputIterator result, BinaryOperation binary_op)
{
	if (first == last)
	{
		return result;	// 区间内容为空直接返回result
	}
	*result = *first;	// 首先记录第一个元素(即原容器中第一个元素内容不变)
	iterator_traits<InputIterator>::value_type value = *first;
	while (++first != last)	
	{
		T tmp = *first;
		*++first = binary_op(tmp, value);
		value = tmp;
	}
	return ++result;
}

3、partial_sum（计算局部总和）

/*
*	函数名：	partial_sum
*	功能：	计算局部总和
*	说明：	与adjacent_difference互为逆运算
*/
// 版本1，算法缺省行为
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result)
{
	if (first == last)
	{
		return result;	// 区间内容为空直接返回result
	}
	*result = *first;	// 首先记录第一个元素(即原容器中第一个元素内容不变)
	iterator_traits<InputIterator>::value_type value = *first;
	while (++first != last)	// 之后的元素为本位置+前一个位置的值
	{
		value = value + *first;
		*++result = value;
	}
	return ++result;
}
 
// 版本2，接收外界传入一个仿函数
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator partial_sum(InputIterator first, InputIterator last, 
							OutputIterator result, BinaryOperation binary_op)
{
	if (first == last)
	{
		return result;	// 区间内容为空直接返回result
	}
	*result = *first;	// 首先记录第一个元素(即原容器中第一个元素内容不变)
	iterator_traits<InputIterator>::value_type value = *first;
	while (++first != last)	
	{
		value = binary_op(value, *first);
		*++result = value;
	}
	return ++result;
}

4、inner_product

/*
*	函数名：	inner_product
*	功能：	计算[first1,last1)和[first2,first2+(last1 - first1))的一般内积
*/
// 版本1，算法缺省行为
template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
				InputIterator2 first2, T init)
{
	// 以第一序列为依据，将两个序列都走一遍
	for (; first1 != last1; ++first1, ++first2)
	{
		init = init + (*first1 * *first2);	//执行两个序列的一般内积
	}
	return init;
}
 
template <class InputIterator1, class InputIterator2, 
		class BinaryOperation1, class BinaryOperation2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
				InputIterator2 first2, T init, 
				BinaryOperation1 binary_op1, BinaryOperation2 binary_op2)
{
	// 以第一序列为依据，将两个序列都走一遍
	for (; first1 != last1; ++first1, ++first2)
	{
		init = binary_op1(init, binary_op2(*first1, *first2));	//执行两个序列的一般内积
	}
	return init;
}

5、iota这个算法是SGI专属，它用来设定区间内的内容，使每个元素从特定的Value，开始递增。

/*
*	函数名：	iota
*	功能：	在区间[first,last)填入value,value+1,value+2,value+3
*/
template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value)
{
	while (first != last)
	{
		*first = value++;
	}
}

参考：

https://www.cnblogs.com/w0w0/archive/2012/04/26/2470853.html

https://blog.csdn.net/hihozoo/article/details/50804202?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-6.compare&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-6.compare