C++标准库算法详解：从基础到实践应用

1. C++算法库概览

C++标准库提供了丰富的算法，主要定义在<algorithm>和<numeric>头文件中。这些算法可以大大简化我们的日常编程工作，避免重复造轮子。根据算法对容器的影响，我们可以将其分为两大类：非修改序列算法和修改序列算法。

1.1 非修改序列算法

非修改序列算法不会改变容器中的元素内容，它们主要用于查询和检查容器中的数据。这类算法包括查找、计数、遍历等操作。

cpp复制#include <algorithm>
#include <vector>
using namespace std;

vector<int> nums = {1, 3, 5, 7, 9};

// 查找值为5的元素
auto it = find(nums.begin(), nums.end(), 5);
if (it != nums.end()) {
    cout << "Found: " << *it << endl;  // 输出：5
}

1.2 修改序列算法

修改序列算法会直接改变容器中的元素内容，包括排序、替换、删除、变换等操作。使用这些算法时需要特别注意迭代器失效问题。

cpp复制vector<int> nums = {1, 2, 3, 4, 5};

// 将每个元素乘以2
transform(nums.begin(), nums.end(), nums.begin(), [](int x) {
    return x * 2;
});
// nums现在为{2, 4, 6, 8, 10}

2. 常用非修改序列算法详解

2.1 查找算法

2.1.1 find和find_if

find用于查找特定值，find_if则可以根据谓词条件查找元素。

cpp复制vector<int> vec = {1, 2, 3, 4, 5};

// 查找值为3的元素
auto it = find(vec.begin(), vec.end(), 3);

// 查找第一个大于3的元素
auto it2 = find_if(vec.begin(), vec.end(), [](int x) {
    return x > 3;
});

注意：如果未找到元素，这些算法会返回end()迭代器，使用前务必检查返回值。

2.1.2 find_end和search

find_end查找子序列最后一次出现的位置，search查找子序列第一次出现的位置。

cpp复制vector<int> main = {1, 2, 3, 4, 1, 2, 3};
vector<int> sub = {1, 2, 3};

// 查找最后一次出现的位置
auto last = find_end(main.begin(), main.end(), sub.begin(), sub.end());

// 查找第一次出现的位置
auto first = search(main.begin(), main.end(), sub.begin(), sub.end());

2.2 计数算法

2.2.1 count和count_if

count统计特定值出现的次数，count_if统计满足条件的元素数量。

cpp复制vector<int> vec = {1, 2, 2, 3, 2, 4, 2};

int cnt = count(vec.begin(), vec.end(), 2);  // 结果为4

int even_cnt = count_if(vec.begin(), vec.end(), [](int x) {
    return x % 2 == 0;
});  // 偶数个数，结果为5

2.3 遍历算法

2.3.1 for_each

for_each对范围内的每个元素应用一个函数，是替代传统for循环的更安全方式。

cpp复制vector<int> vec = {1, 2, 3, 4, 5};

for_each(vec.begin(), vec.end(), [](int& x) {
    x *= 2;  // 将每个元素乘以2
});

2.4 比较算法

2.4.1 equal和mismatch

equal判断两个范围是否相等，mismatch返回第一个不匹配的元素对。

cpp复制vector<int> a = {1, 2, 3};
vector<int> b = {1, 2, 4};

bool same = equal(a.begin(), a.end(), b.begin());  // false

auto mis = mismatch(a.begin(), a.end(), b.begin());
// mis.first指向3，mis.second指向4

2.4.2 all_of/any_of/none_of

这些算法检查范围内元素是否全部/存在/没有满足特定条件。

cpp复制vector<int> vec = {2, 4, 6, 8};

bool all_even = all_of(vec.begin(), vec.end(), [](int x) {
    return x % 2 == 0;
});  // true

bool any_odd = any_of(vec.begin(), vec.end(), [](int x) {
    return x % 2 != 0;
});  // false

3. 常用修改序列算法详解

3.1 复制算法

3.1.1 copy和copy_if

copy复制整个范围，copy_if只复制满足条件的元素。

cpp复制vector<int> src = {1, 2, 3, 4, 5};
vector<int> dest(src.size());

copy(src.begin(), src.end(), dest.begin());

vector<int> evens;
copy_if(src.begin(), src.end(), back_inserter(evens), [](int x) {
    return x % 2 == 0;
});  // evens: {2, 4}

提示：使用back_inserter可以自动处理目标容器空间不足的问题。

3.2 变换算法

3.2.1 transform

transform对范围内的元素应用一个函数，并将结果存储到目标范围。

cpp复制vector<int> nums = {1, 2, 3};
vector<int> squares(nums.size());

transform(nums.begin(), nums.end(), squares.begin(), [](int x) {
    return x * x;
});  // squares: {1, 4, 9}

3.3 替换算法

3.3.1 replace系列

replace替换特定值，replace_if替换满足条件的元素。

cpp复制vector<int> nums = {1, 2, 3, 2, 5};

replace(nums.begin(), nums.end(), 2, 20);  // 替换所有2为20

replace_if(nums.begin(), nums.end(), [](int x) {
    return x > 10;
}, 0);  // 替换大于10的元素为0

3.4 删除算法

3.4.1 remove系列

remove和remove_if实际上并不删除元素，而是将不需要的元素移动到容器末尾。

cpp复制vector<int> nums = {1, 2, 3, 2, 4};

auto new_end = remove(nums.begin(), nums.end(), 2);  // nums: {1, 3, 4, 2, 2}
nums.erase(new_end, nums.end());  // 真正删除元素

重要：remove算法必须配合erase使用才能真正删除元素，这是C++中常见的erase-remove惯用法。

3.4.2 unique

unique移除连续的重复元素，通常也需要配合erase使用。

cpp复制vector<int> vec = {1, 1, 2, 2, 3, 3, 3, 4, 5};

auto last = unique(vec.begin(), vec.end());
vec.erase(last, vec.end());  // vec: {1, 2, 3, 4, 5}

3.5 排序算法

3.5.1 sort和stable_sort

sort是快速排序实现，stable_sort是稳定的归并排序。

cpp复制vector<int> vec = {5, 3, 1, 4, 2};

sort(vec.begin(), vec.end());  // 默认升序

stable_sort(vec.begin(), vec.end(), greater<int>());  // 稳定降序排序

3.5.2 partial_sort

partial_sort对部分元素进行排序，常用于获取前N个最小/最大元素。

cpp复制vector<int> vec = {5, 3, 1, 4, 2, 6};

// 将最小的3个元素放在前面并排序
partial_sort(vec.begin(), vec.begin() + 3, vec.end());
// vec前三个元素是1, 2, 3，后面是未排序的4, 5, 6

3.5.3 nth_element

nth_element重新排列元素，使得第n个位置的元素是正确的。

cpp复制vector<int> vec = {5, 3, 1, 4, 2, 6};

// 找到第三小的元素
nth_element(vec.begin(), vec.begin() + 2, vec.end());
// vec[2]是3，左边<=3，右边>=3

3.6 二分查找算法

这些算法要求范围已经是排序的。

3.6.1 binary_search

binary_search检查值是否存在。

cpp复制vector<int> sorted = {1, 3, 3, 5, 7};

bool exists = binary_search(sorted.begin(), sorted.end(), 3);  // true

3.6.2 lower_bound和upper_bound

lower_bound返回第一个不小于给定值的迭代器，upper_bound返回第一个大于给定值的迭代器。

cpp复制vector<int> sorted = {1, 3, 3, 5, 7};

auto lb = lower_bound(sorted.begin(), sorted.end(), 3);  // 指向第一个3
auto ub = upper_bound(sorted.begin(), sorted.end(), 3);  // 指向5

3.7 合并算法

3.7.1 merge

merge合并两个已排序的范围。

cpp复制vector<int> a = {1, 3, 5};
vector<int> b = {2, 4, 6};
vector<int> merged(a.size() + b.size());

merge(a.begin(), a.end(), b.begin(), b.end(), merged.begin());
// merged: {1, 2, 3, 4, 5, 6}

4. 数值算法

这些算法定义在<numeric>头文件中。

4.1 accumulate

accumulate计算累加和或自定义操作的结果。

cpp复制#include <numeric>

vector<int> vec = {1, 2, 3, 4, 5};

int sum = accumulate(vec.begin(), vec.end(), 0);  // 和，结果为15

int product = accumulate(vec.begin(), vec.end(), 1, multiplies<int>());  // 乘积，120

4.2 inner_product

inner_product计算两个范围的内积。

cpp复制vector<int> a = {1, 2, 3};
vector<int> b = {4, 5, 6};

int dot = inner_product(a.begin(), a.end(), b.begin(), 0);  // 1*4 + 2*5 + 3*6 = 32

4.3 iota

iota用连续递增的值填充范围。

cpp复制vector<int> vec(5);
iota(vec.begin(), vec.end(), 10);  // 填充为10, 11, 12, 13, 14

4.4 partial_sum

partial_sum计算部分和。

cpp复制vector<int> src = {1, 2, 3, 4, 5};
vector<int> dst(src.size());

partial_sum(src.begin(), src.end(), dst.begin());  // dst: {1, 3, 6, 10, 15}

5. 算法使用技巧与注意事项

5.1 迭代器失效问题

在使用修改序列算法时，需要注意迭代器失效的问题。特别是对容器进行插入或删除操作后，原有的迭代器可能会失效。

cpp复制vector<int> vec = {1, 2, 3, 4, 5};
auto it = vec.begin() + 2;  // 指向3

vec.erase(vec.begin());  // 删除第一个元素
// 此时it可能已经失效，不能再使用

5.2 谓词的设计

许多算法接受谓词函数，设计良好的谓词可以提高代码的可读性和性能。

cpp复制// 不好的谓词设计
auto pred = [](int x) { return x > 5 && x < 10 && x % 2 == 0; };

// 更好的设计
bool is_even_in_range(int x) {
    const int lower = 5;
    const int upper = 10;
    return x > lower && x < upper && x % 2 == 0;
}

5.3 算法性能考虑

不同算法的时间复杂度不同，应根据实际需求选择合适的算法。

• find: O(n)
• binary_search: O(log n) (但要求范围已排序)
• sort: O(n log n)
• nth_element: O(n)

6. 实际应用案例

6.1 统计文本词频

cpp复制#include <algorithm>
#include <map>
#include <vector>
#include <string>

vector<string> words = {"apple", "banana", "apple", "cherry", "banana", "apple"};

map<string, int> word_counts;
for (const auto& word : words) {
    ++word_counts[word];
}

// 按词频排序
vector<pair<string, int>> sorted_counts(word_counts.begin(), word_counts.end());
sort(sorted_counts.begin(), sorted_counts.end(), [](const auto& a, const auto& b) {
    return a.second > b.second;
});

6.2 过滤无效数据

cpp复制vector<int> data = {1, -1, 2, -2, 3, -3, 4, -4};

// 移除所有负数
data.erase(remove_if(data.begin(), data.end(), [](int x) {
    return x < 0;
}), data.end());

6.3 查找公共元素

cpp复制vector<int> a = {1, 2, 3, 4, 5};
vector<int> b = {3, 4, 5, 6, 7};
vector<int> common;

set_intersection(a.begin(), a.end(), b.begin(), b.end(), back_inserter(common));
// common: {3, 4, 5}

7. 常见问题解答

7.1 为什么remove不真正删除元素？

remove算法设计为通用算法，它不知道容器的具体实现，因此无法直接修改容器大小。它只是将不需要的元素移动到末尾，返回新的逻辑结尾。真正的删除需要通过容器的erase方法完成。

7.2 sort和stable_sort如何选择？

如果需要保持相等元素的相对顺序，使用stable_sort。否则，通常sort性能更好，因为它使用的是快速排序的变体(introsort)。

7.3 如何自定义排序规则？

可以通过传递自定义比较函数或函数对象来定义排序规则。

cpp复制vector<string> words = {"apple", "banana", "cherry"};

// 按长度排序
sort(words.begin(), words.end(), [](const string& a, const string& b) {
    return a.size() < b.size();
});

7.4 算法如何处理空范围？

所有标准算法都能正确处理空范围(即begin == end)。例如，find会返回end，count会返回0，sort不会有任何效果。

7.5 如何提高算法性能？

1. 对于大型数据集，优先使用O(n log n)或更好的算法
2. 避免在循环内调用算法
3. 尽可能复用已排序的范围进行多次操作
4. 考虑使用并行算法(C++17引入的并行版本)