突破编程_C++_STL教程（数值算法（2））

最新推荐文章于 2024-05-10 16:16:17 发布
最新推荐文章于 2024-05-10 16:16:17 发布
阅读量628 收藏 8
点赞数 4
分类专栏： 突破编程_C++_STL教程 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h8062651/article/details/137287545
版权

1 std::partial_sum

1.1 基本概念

std::partial_sum 用于计算一个序列的部分和。具体地说，给定一个输入范围（比如一个数组或向量），std::partial_sum 会计算这个范围内每个位置及其之前所有元素的和，并将结果存储在一个输出范围内。

其函数原型如下：

template< class InputIt, class OutputIt >  
OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );  
  
template< class InputIt, class OutputIt, class BinaryOperation >  
OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op );
  • first 和 last 是输入范围的迭代器。
  • d_first 是输出范围的开始迭代器。
  • binary_op 是一个二元操作，用于替代默认的加法操作

1.2 基本用法

假设有一个整数向量 v，现在需要计算它的部分和：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::partial_sum  
#include <iterator> // for std::back_inserter  
  
int main() {  
    std::vector<int> v = {1, 2, 3, 4, 5};  
    std::vector<int> partialSums;  
  
    // 使用 back_inserter 来自动调整 partialSums 的大小  
    std::partial_sum(v.begin(), v.end(), std::back_inserter(partialSums));  
  
    for (int sum : partialSums) {  
        std::cout << sum << ' ';  
    }  
    // 输出: 1 3 6 10 15  
    return 0;  
}

上面代码的输出为：

1 3 6 10 15

在这个例子中，partialSums 会包含以下元素：[1, 1+2, 1+2+3, 1+2+3+4, 1+2+3+4+5]。

1.3 使用自定义二元操作

还可以提供一个自定义的二元操作来替代默认的加法。例如，如果需要计算部分乘积而不是部分和，则可以这样做：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::partial_sum  
#include <iterator> // for std::back_inserter  
  
int main() {  
    std::vector<int> v = {1, 2, 3, 4, 5};  
    std::vector<int> partialSums;  
  
    // 使用 back_inserter 来自动调整 partialSums 的大小  
    std::partial_sum(v.begin(), v.end(), std::back_inserter(partialSums));  
  
    for (int sum : partialSums) {  
        std::cout << sum << ' ';  
    }  
    // 输出: 1 3 6 10 15  
    return 0;  
}

上面代码的输出为：

1 2 6 24 120

在这个例子中，partialProducts 会包含以下元素：[1, 12, 123, 1234, 12345]。

1.4 使用自定义数据结构

std::partial_sum 可以应用于任何可以定义加法操作的数据类型，包括自定义的数据结构。对于自定义的数据结构，只需要需要重载加法操作符（operator+）或提供一个自定义的二元操作函数对象或 lambda 表达式，这样 std::partial_sum 才能知道如何计算部分和。

下面是一个使用 std::partial_sum 对自定义数据结构进行部分求和的示例：

首先，定义一个自定义的数据结构，并重载加法操作符：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::partial_sum  
#include <iterator> // for std::back_inserter  

// 自定义数据结构  
struct ComplexNumber {
	double real;
	double imag;

	// 重载加法操作符  
	ComplexNumber operator+(const ComplexNumber& other) const {
		return { real + other.real, imag + other.imag };
	}

	// 重载输出操作符，方便打印  
	friend std::ostream& operator<<(std::ostream& os, const ComplexNumber& cn) {
		os << "(" << cn.real << ", " << cn.imag << ")";
		return os;
	}
};

int main() {
	std::vector<ComplexNumber> complexNumbers = {
		{1.0, 2.0},
		{3.0, 4.0},
		{5.0, 6.0}
	};
	std::vector<ComplexNumber> partialSums;

	// 使用 std::partial_sum 计算部分和  
	std::partial_sum(complexNumbers.begin(), complexNumbers.end(), std::back_inserter(partialSums));

	// 打印结果  
	for (const auto& sum : partialSums) {
		std::cout << sum << ' ';
	}
	// 输出: (1, 2) (4, 6) (9, 12)  

	return 0;
}

上面代码的输出为：

(1, 2) (4, 6) (9, 12)

这个例子定义了一个 ComplexNumber 结构体来表示复数，并重载了加法操作符 operator+。这样就可以直接对 ComplexNumber 对象使用 std::partial_sum。程序会输出每个 ComplexNumber 对象及其之前所有对象的和。

如果不想或不能重载加法操作符，则可以提供一个自定义的二元操作函数对象或 lambda 表达式给 std::partial_sum 的第四个参数。例如：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::partial_sum  
#include <iterator> // for std::back_inserter  
#include <functional> // for std::plus  
  
// 自定义数据结构（这次不重载加法操作符）  
struct ComplexNumber {  
    double real;  
    double imag;  
  
    // ... 其他成员函数和操作符 ...  
};  
  
// 自定义二元操作，用于计算两个 ComplexNumber 的和  
struct ComplexNumberAdd {  
    ComplexNumber operator()(const ComplexNumber& a, const ComplexNumber& b) const {  
        return {a.real + b.real, a.imag + b.imag};  
    }  
};  
  
int main() {  
    std::vector<ComplexNumber> complexNumbers = {  
        {1.0, 2.0},  
        {3.0, 4.0},  
        {5.0, 6.0}  
    };  
    std::vector<ComplexNumber> partialSums;  
  
    // 使用自定义的二元操作计算部分和  
    std::partial_sum(complexNumbers.begin(), complexNumbers.end(), std::back_inserter(partialSums), ComplexNumberAdd());  
  
    // 打印结果（同前例）  
    for (const auto& sum : partialSums) {  
        std::cout << "(" << sum.real << ", " << sum.imag << ") ";  
    }  
    // 输出: (1, 2) (4, 6) (9, 12)  
  
    return 0;  
}

上面代码的输出为：

(1, 2) (4, 6) (9, 12)

这个例子定义了一个名为 ComplexNumberAdd 的结构体，它重载了调用操作符 operator() 来计算两个 ComplexNumber 对象的和。然后将这个自定义的二元操作作为第四个参数传递给 std::partial_sum。这样，std::partial_sum 就可以使用这个自定义操作来计算 ComplexNumber 对象的部分和了。

2 std::adjacent_difference

2.1 基本概念

std::adjacent_difference 用于计算一个序列中相邻元素的差值（或更一般地说，是相邻元素之间通过某个二元操作得到的结果）。它通常用于计算序列中每个元素与其前一个元素之间的差值，并将结果存储在一个输出序列中。

其函数原型如下：

template< class InputIt, class OutputIt >  
OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first );  
  
template< class InputIt, class OutputIt, class BinaryOperation >  
OutputIt adjacent_difference( InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op );
  • first 和 last 是输入范围的迭代器。
  • d_first 是输出范围的开始迭代器。
  • binary_op 是一个二元操作，用于替代默认的加法操作

2.2 基本用法

假设有一个整数向量 v，现在需要计算其中每个元素与其前一个元素之间的差值：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::adjacent_difference  
#include <iterator> // for std::back_inserter  
  
int main() {  
    std::vector<int> v = {1, 3, 6, 10, 15};  
    std::vector<int> differences;  
  
    // 使用 back_inserter 来自动调整 differences 的大小  
    std::adjacent_difference(v.begin(), v.end(), std::back_inserter(differences));  
  
    // 输出结果  
    for (int diff : differences) {  
        std::cout << diff << ' ';  
    }  
  
    return 0;  
}

上面代码的输出为：

1 2 3 4 5

在这个例子中，differences 将会包含以下元素：[1, 3-1, 6-3, 10-6, 15-10]，即 [1, 2, 3, 4, 5]。注意，第一个元素与它自己的差值就是它本身，因此 differences 的第一个元素是 v 的第一个元素。

2.3 使用自定义二元操作

也可以提供一个自定义的二元操作来替代默认的减法。例如，如果想计算相邻元素的乘积而不是差值，则可以这样做：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::adjacent_difference  
#include <iterator> // for std::back_inserter  
#include <functional> // for std::multiplies  

int main() {
	std::vector<int> v = { 1, 2, 3, 4, 5 };
	std::vector<int> products;

	// 使用 std::multiplies 作为二元操作来计算相邻元素的乘积  
	std::adjacent_difference(v.begin(), v.end(), std::back_inserter(products), std::multiplies<int>());

	// 输出结果  
	for (int prod : products) {
		std::cout << prod << ' ';
	}

	return 0;
}

上面代码的输出为：

1 2 6 12 20

在这个例子中，products 将会包含以下元素：[1, 21, 32, 43, 54]，即 [1, 2, 6, 12, 60]。

2.4 使用自定义数据结构

std::adjacent_difference 算法可以应用于任何支持二元操作的类型，包括自定义数据结构。对于自定义数据结构，只需要确保你提供了合适的二元操作，并且这个操作能够处理自定义数据结构类型的两个对象，并返回一个新的对象。

例如，假设有一个自定义的 Point 类，表示二维平面上的点，并且想要计算一系列点中相邻点之间的差（即向量）。则可以这样实现：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::adjacent_difference  
#include <iterator> // for std::back_inserter  
  
// 自定义的 Point 类  
class Point {  
public:  
    int x, y;  
  
    Point(int x = 0, int y = 0) : x(x), y(y) {}  
  
    // 重载减法操作符，返回两个点之间的向量差  
    Point operator-(const Point& other) const {  
        return Point(x - other.x, y - other.y);  
    }  
  
    // 重载输出操作符，方便打印 Point 对象  
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {  
        os << "(" << p.x << ", " << p.y << ")";  
        return os;  
    }  
};  
  
int main() {  
    // 创建一个包含多个点的向量  
    std::vector<Point> points = {  
        {1, 2},  
        {4, 6},  
        {7, 10},  
        {10, 14}  
    };  
  
    // 创建一个向量来存储相邻点之间的差（向量）  
    std::vector<Point> differences;  
  
    // 使用 std::adjacent_difference 计算相邻点之间的差，并将结果存储到 differences 中  
    std::adjacent_difference(points.begin(), points.end(), std::back_inserter(differences));  
  
    // 输出结果  
    for (const Point& diff : differences) {  
        std::cout << diff << ' ';  
    }  
  
    return 0;  
}

上面代码的输出为：

(1, 2) (3, 4) (3, 4) (3, 4)

在这个例子中，Point 类重载了减法操作符，以便 std::adjacent_difference 可以使用它来计算相邻点之间的向量差。std::adjacent_difference 默认使用减法操作符，但如果你的数据结构不支持减法或者你需要执行其他类型的二元操作，你可以提供一个自定义的二元操作函数对象或 lambda 表达式作为 std::adjacent_difference 的第四个参数。

3 std::iota

3.1 基本概念

std::iota 用于将一个序列的元素填充为连续递增的值。这个算法特别适用于初始化一个容器，使其包含一系列连续递增的整数或其他类型的值。

其函数原型如下：

template< class ForwardIt, class T >  
void iota( ForwardIt first, ForwardIt last, T value );
  • first 和 last 是表示序列范围的迭代器，first 指向序列中的第一个元素，last 指向序列“尾后”的位置（即不包含在填充范围内的位置）。
  • value 是序列中第一个元素的值，随后的元素将依次递增。

3.2 基本用法

std::iota 的用法非常简单。只需要提供序列的起始和结束迭代器，以及序列中第一个元素的值即可。下面是一个例子，展示了如何使用 std::iota 来初始化一个 std::vector<int>：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::iota  

int main() {
	std::vector<int> v(10); // 创建一个包含10个元素的vector，所有元素初始化为0  

	// 使用std::iota将vector的元素初始化为从0开始的连续整数  
	std::iota(v.begin(), v.end(), 0);

	// 输出vector的内容  
	for (int i : v) {
		std::cout << i << ' ';
	}
	return 0;
}

上面代码的输出为：

0 1 2 3 4 5 6 7 8 9

这个例子创建了一个包含 10 个元素的 std::vector<int>。然后，使用 std::iota 来初始化这个 vector，使其包含从 0 开始的连续整数。最后，遍历并打印出 vector 中的所有元素。

3.3 使用自定义数据结构

std::iota 算法通常用于生成连续递增的整数序列，但如果需要在一个容器中使用自定义数据结构的对象，并让这些对象之间以一种特定的方式“递增”，则要确保自定义数据结构支持递增操作，并且这个操作是符合期望的。

对于自定义数据结构，递增操作通常通过重载 ++ 操作符来实现。然而，std::iota 默认使用 ++ 操作符以递增的方式填充序列，这可能并不适用于所有类型的自定义数据结构。如果自定义数据结构不适合使用递增操作符，或者递增的含义不符合实际的需求，那么 std::iota 可能不是最佳选择。

但是，如果自定义数据结构确实可以通过递增来生成序列，并且需要使用 std::iota，则可以这样做：

  • 定义自定义数据结构，并重载 ++ 操作符。
  • 创建一个容器，用于存储自定义数据结构的对象。
  • 使用 std::iota 初始化这个容器，传入起始迭代器、结束迭代器和初始值。

下面是一个简单的例子，展示了如何为自定义数据结构使用 std::iota：

#include <iostream>  
#include <vector>  
#include <numeric> // for std::iota  

// 自定义数据结构  
class MyData {
public:
	int value;

	// 构造函数  
	MyData(int val = 0) : value(val) {}

	// 重载递增操作符  
	MyData& operator++() {
		++value; // 递增内部值  
		return *this;
	}

	// 重载输出操作符，方便打印对象  
	friend std::ostream& operator<<(std::ostream& os, const MyData& data) {
		os << data.value;
		return os;
	}
};

int main() {
	// 创建一个存储自定义数据结构的vector  
	std::vector<MyData> vec(5); // 创建一个包含5个MyData对象的vector  

	// 使用std::iota初始化vector，从MyData(1)开始递增  
	MyData initialValue(1); // 初始值  
	std::iota(vec.begin(), vec.end(), initialValue);

	// 输出vector的内容  
	for (const MyData& data : vec) {
		std::cout << data << ' ';
	} 

	return 0;
}

上面代码的输出为：

1 2 3 4 5

这个例子定义了一个 MyData 类，它包含一个 int 类型的 value 成员。然后重载了 ++ 操作符来递增 value 的值，并重载了输出操作符以便能够打印 MyData 对象。接下来，创建了一个 std::vector<MyData>，并使用 std::iota 来初始化它，从 MyData(1) 开始，并依次递增每个对象的 value 值。

注意：重载 ++ 操作符通常用于前置递增（如 ++x），但 std::iota 使用的是后置递增（如 x++）的语义。在 C++ 中，前置和后置递增可以有不同的行为，但在这个例子中，我们只关心递增操作本身，而不关心返回值，所以简单递增 value 并返回当前对象的引用是足够的。

breakthrough_01
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11标准模板（STL）- 算法 - 数值运算（std::partial_sum）
qq_40788199的博客
12-28 1097
计算范围内元素的部分和。 计算范围 [first, last) 的子范围中元素的部分和，并写入到始于 d_first 的范围。第一版本用 operator+ ，第二版本用给定的二元函数 op 对元素求和，均将 std::move 应用到其左侧运算数 (C++20 起)。
partial_sum 的使用
思不凉
06-09 7281
partial_sum 的使用 partial_sum 是C++ STL 算法组件中的其中一个算法，其作用是计算某个序列局部元素的和。它有四个重载函数。要使用 partial_sum 需要引用头文件 numeric。 下面是一个例子： 头文件、命名空间的引用，main方法，定义容器并赋值，输出容器，使用partial_sum： 代码： #include<iostream> #inc...
C++---partial_sum的用法
最新发布
Frank---7的博客
05-10 264
是 C++ 标准库中的一个函数，用于计算指定范围内的部分和，并将结果存储在另一个范围中。具体来说，它将输入序列的元素累积相加，并将每个累积值存储到输出序列中。下面是firstlastd_first函数会计算从first到last的范围内的部分和，并将结果存储到从d_first开始的范围中。第一个元素直接拷贝到输出序列中，然后依次计算每个元素的累积和。以下是一个示例，展示了如何使用在这个示例中，函数将nums中的元素累积相加，并将结果存储到result中。然后，我们输出了计算得到的部分和。
STL --- 八. STL的高级特性和应用实例
bigger_belief的博客
05-30 1119
STL的高级特性和应用实例，并附上一些实例
std::partial_sum示例代码
davidhopper的博客
08-27 495
`std::partial_sum`用于求取序列的累加值，例如：原序列为：`1, 2, 3, 4, 5`，累加后的序列为：`1, 3, 6, 10, 15`。可以使用带系数的版本，例如乘以系数`1.2`，累加后的序列为：`1, 3.6, 7.92, 14.304, 23.1648`。......
ACM_ICPC2008.zip_数值算法/人工智能_C++_
08-12
3. C++编程技巧，如何高效地实现数值算法和AI算法，包括模板、STL容器、智能指针等高级特性。 4. 案例分析，详细解析历届比赛中的经典问题，如何运用数值算法和人工智能来提高解题效率。 5. 训练策略和实战经验分享...
07082815.zip_数值算法/人工智能_C++_
08-10
在这个场景中，我们关注的是使用数值算法和人工智能技术，特别是C++编程语言来解决这一问题。数值算法通常用于处理数学计算，而人工智能则涵盖了解决复杂问题的策略，如搜索、优化和学习。下面我们将深入探讨迷宫...
paixu.zip_数值算法/人工智能_C++_
08-11
"paixu.zip"这个压缩包显然包含了与数值算法和C++编程相关的排序程序，这为我们提供了一个深入学习这些主题的机会。 首先，让我们讨论数值算法。排序是计算机科学中最基础的数值算法之一，它的目的是重新排列一组...
data_manipulation.rar_数值算法/人工智能_Visual_C++_
08-12
在本文中，我们将深入探讨与"数值算法/人工智能"相关的编程知识，特别是在Visual C++环境下的实现。"data_manipulation.rar"这个压缩包文件包含了多种数据处理算法，旨在帮助开发者提升在数值计算和人工智能领域的...
Finding_path.zip_数值算法/人工智能_Visual_C++_
08-11
在IT领域，数值算法和人工智能是两个至关重要的子领域，它们在解决复杂问题时发挥着核心作用。在本例中，我们关注的是一个基于Visual C++实现的算法，该算法旨在寻找图中任意两点之间的最短路径。这个任务在很多实际...
C++ STL 函数partial_sum的正确使用方法
热门推荐
Ibelievesunshine的博客
05-14 1万+
partial_sum 对于序列 a,b,c,d 产生序列 a,a+b,a+b+c,a+b+c+d。//本程序实例演示partial_sum函数的正确使用方式 #include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; #include &lt;numeric&gt; using namespace st...
C++ | 部分和函数partial_sum的使用技巧
brilliantgby_id的博客
02-03 1109
partial_sum函数是STL中的函数，用于计算范围的部分和，并从结果开始分配范围中的每个元素，range[first,last)中相应元素的部分和。
c语言计算sum,C++ partial_sum(STL partial_sum)部分和计算方法详解
weixin_30423863的博客
05-21 1091
定义在 header 头文件中的 partial_sum() 可以计算输入序列中元素的部分和，并将结果保存到一个输出序列中。partial_sum() 会计算出输入序列中长度从1开始不断增加的序列的和，所以第一个输出值就是第一个元素，下一个值是前两个元素的和，再下一个值就是前三个元素的和，以此类推。这和 adjacent_difference() 算法是相反的，因此 partial_sum() 不...
STL前缀和及差分函数-partial_sum，adjacent_difference
zhengzhiyun2011的博客
08-07 228
STL关于前缀和及差分的函数简介
13届蓝桥杯c++组日常练习问题记录
sgsx11的博客
03-27 2752
13届蓝桥杯c++组日常练习问题记录.md 以下内容皆收集于相关博客，如有侵权请联系我删除！ 一、常用函数 1、C++ STL中 next_permutation函数的用法 1.1 输出序列{1,2,3,4}字典序的全排列。 #include <iostream> #include<algorithm> using namespace std; int main(int argc, char** argv) { int a[4]={1,2,3,4}; sort(a,a+4)
c++accumulate()，partial_sum()，fill()函数
zhangtingxiqwq的博客
08-13 86
【代码】c++accumulate()，partial_sum()，fill()函数。
c++ stl 数值算法 将相对值转换成绝对值partial_sum使用方法
qq_44800780的博客
02-06 643
使用例子： template<typename T> inline void INSERT_ELEMENTS(T& coll, int first, int last) { for (int i = first; i <= last; ++i) { coll.insert(coll.end(), i); } } template<typename T&g...
STL之partial_sum
记录学习的过程
09-12 1604
需要的头文件： numeric源码：//版本1 template <class _InputIterator, class _OutputIterator, class _Tp> _OutputIterator __partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterat
STL C++实用教程：数据结构与算法详解
STL（Standard Template Library）是C++编程语言的标准库，它提供了一系列通用的数据结构和算法模板，使得开发者能高效地处理复杂的数据处理和操作。本文档由袁辉勇于2009年11月整理，旨在帮助读者理解和掌握STL的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值