学懂C++（四十六）：深入探索C++ STL算法（Algorithms）：从基础到高级应用

猿享天开

于 2024-08-27 12:56:06 发布

阅读量344

点赞数 5

分类专栏：学懂C++语言-C++核心编程精讲文章标签： c++ 开发语言 STL算法

本文链接：https://blog.csdn.net/martian665/article/details/141600051

版权

学懂C++语言-C++核心编程精讲专栏收录该内容

47 篇文章 6 订阅

订阅专栏

5.2 std::inner_product

引言

C++标准模板库（STL）中的算法是其强大的基石之一。它提供了一系列广泛用于各种数据处理的算法，这些算法与STL容器、迭代器一起使用，为开发者提供了高度灵活和高效的编程工具。本文将详细介绍STL中的常用算法，涵盖其概念、特点、核心点、实现方法和适用场景，并通过经典示例进行详细解析。

1. STL算法概述

STL算法是一组通用算法的集合，用于操作序列。它们独立于容器，通过迭代器与任何容器一起使用。STL算法可分为以下几类：

非修改性算法：如查找和计数。
修改性算法：如复制、替换和删除。
排序算法：如排序、合并和分区。
数值算法：如求和和积。

2. 非修改性算法

2.1 `std::find`

概念：查找指定范围内的第一个等于给定值的元素。
特点：线性时间复杂度O(n)。
核心点：从范围的起始位置到终止位置逐个比较元素。
实现：

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = std::find(vec.begin(), vec.end(), 3);
    if (it != vec.end()) {
        std::cout << "Element found: " << *it << std::endl;
    } else {
        std::cout << "Element not found" << std::endl;
    }
    return 0;
}

解析：std::find在vec的范围内查找值为3的元素，并返回一个指向该元素的迭代器。如果未找到，则返回vec.end()。

2.2 `std::count`

概念：统计指定范围内等于给定值的元素个数。
特点：线性时间复杂度O(n)。
核心点：遍历范围内的所有元素并计数。
实现：

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

int main() {
    std::vector<int> vec = {1, 2, 3, 3, 4, 5};
    int count = std::count(vec.begin(), vec.end(), 3);
    std::cout << "Count of 3: " << count << std::endl;
    return 0;
}

解析：std::count在vec的范围内统计值为3的元素个数，并返回计数结果。

3. 修改性算法

3.1 `std::copy`

概念：将指定范围内的元素复制到另一个范围。
特点：线性时间复杂度O(n)。
核心点：确保目标范围有足够的空间容纳复制的元素。
实现：

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

int main() {
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::vector<int> vec2(5);
    std::copy(vec1.begin(), vec1.end(), vec2.begin());
    for (int n : vec2) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

解析：std::copy将vec1的元素复制到vec2中，确保vec2有足够的空间存放这些元素。

3.2 `std::replace`

概念：将指定范围内等于给定值的元素替换为新值。
特点：线性时间复杂度O(n)。
核心点：遍历范围内的所有元素并进行替换。
实现：

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

int main() {
    std::vector<int> vec = {1, 2, 3, 3, 4, 5};
    std::replace(vec.begin(), vec.end(), 3, 9);
    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

解析：std::replace将vec范围内值为3的元素替换为9。

4. 排序算法

4.1 `std::sort`

概念：对指定范围内的元素进行升序排序。
特点：平均时间复杂度O(n log n)。
核心点：使用快速排序、堆排序或插入排序的组合。
实现：

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

int main() {
    std::vector<int> vec = {5, 2, 4, 3, 1};
    std::sort(vec.begin(), vec.end());
    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

解析：std::sort对vec的元素进行升序排序。

4.2 `std::stable_sort`

概念：对指定范围内的元素进行稳定排序，保证相等元素的相对顺序不变。
特点：时间复杂度O(n log n)。
核心点：通常实现为归并排序。
实现：

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

int main() {
    std::vector<int> vec = {5, 2, 2, 3, 1};
    std::stable_sort(vec.begin(), vec.end());
    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

解析：std::stable_sort对vec的元素进行稳定排序。

5. 数值算法

5.1 `std::accumulate`

概念：计算指定范围内元素的累积和。
特点：线性时间复杂度O(n)。
核心点：指定初始值和累加函数。
实现：

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

解析：std::accumulate计算vec中所有元素的累积和，初始值为0。

5.2 `std::inner_product`

概念：计算两个范围内元素的内积。
特点：线性时间复杂度O(n)。
核心点：指定初始值和两个二元操作。
实现：

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    int product = std::inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    std::cout << "Inner product: " << product << std::endl;
    return 0;
}

解析：std::inner_product计算vec1和vec2的内积，初始值为0。

6. 高级算法应用

6.1 `std::transform`

概念：对指定范围内的元素应用一个函数，并将结果存储到另一个范围。
特点：线性时间复杂度O(n)。
核心点：支持一元和二元操作。
实现：

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());
    std::transform(vec.begin(), vec.end(), result.begin(), [](int x) { return x * 2; });
    for (int n : result) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}

解析：std::transform对vec的每个元素应用乘以2的操作，并将结果存储在result中。

6.2 `std::partial_sum`

概念：计算部分和，即每个元素是前面所有元素的累积和。
特点：线性时间复杂度O(n)。
核心点：指定初始值和累加函数。
实现：

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());
    std::partial_sum(vec.begin(), vec.end(), result.begin());
    for (int n : result) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    return 0;
}