c++ STL标准模板库-算法-优快云博客

本文链接：https://blog.youkuaiyun.com/u010196944/article/details/143163092

C++ Standard Template Library（STL）算法是一组泛型算法，它们可以在各种容器上操作。这些算法被设计为与容器无关，因此可以在任何提供必要迭代器接口的容器上使用。STL算法分为以下几个主要类别：

非修改算法Non-modifying sequence operations：不改变容器内容，主要用于搜索和排序。
修改算法Modifying sequence operations：改变容器内容，如替换元素或改变元素顺序。
杂项算法：包括设置操作、堆操作等。

由于算法数量较多，我将按照分类逐一列出所有算法的详细介绍和函数原型，以及相应的简单示例。

Non-modifying sequence operations

std::all_of
- 函数原型：template <class InputIterator, class UnaryPredicate> bool all_of(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：检查范围内所有元素是否满足条件
```
std::vector<int> v = {
       1, 2, 3, 4, 5};
bool all_positive = std::all_of(v.begin(), v.end(), [](int i) {
        return i > 0; });
```
std::any_of
- 函数原型：template <class InputIterator, class UnaryPredicate> bool any_of(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：检查范围内是否有元素满足条件
```
bool has_positive = std::any_of(v.begin(), v.end(), [](int i) {
        return i > 0; });
```
std::none_of
- 函数原型：template <class InputIterator, class UnaryPredicate> bool none_of(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：检查范围内是否没有元素满足条件
```
bool no_negative = std::none_of(v.begin(), v.end(), [](int i) {
        return i < 0; });
```
std::for_each
- 函数原型：template <class InputIterator, class Function> Function for_each(InputIterator first, InputIterator last, Function f);
- 示例：对每个元素应用函数对象

	std::vector<int> v = {
   1, 2, 3, 4, 5};
	std::for_each(v.begin(), v.end(), [](int i) {
    std::cout << i << ' '; });

std::find
- 函数原型：template <class InputIterator, class T> InputIterator find(InputIterator first, InputIterator last, const T& value);
- 示例：查找特定值的第一个匹配项

std::vector<int> v = {
   1, 2, 3, 4, 5};
auto it = std::find(v.begin(), v.end(), 3);

std::find_if
- 函数原型：template <class InputIterator, class UnaryPredicate> InputIterator find_if(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：查找第一个满足条件的元素
```
auto it = std::find_if(v.begin(), v.end(), [](int i) {
        return i > 3; });
```
std::find_if_not
- 函数原型：template <class InputIterator, class UnaryPredicate> InputIterator find_if_not(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：查找第一个不满足条件的元素
```
auto it = std::find_if_not(v.begin(), v.end(), [](int i) {
        return i > 3; });
```
std::find_end
- 函数原型：template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
- 示例：查找最后一个子序列的匹配项
```
std::vector<int> v1 = {
       1, 2, 3, 4, 5, 1, 2};
std::vector<int> v2 = {
       4, 5, 1};
auto it = std::find_end(v1.begin(), v1.end(), v2.begin(), v2.end());
```
std::find_first_of
- 函数原型：template <class InputIterator1, class InputIterator2, class BinaryPredicate> InputIterator1 find_first_of(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred);
- 示例：查找第一个来自另一个范围的元素
```
std::vector<int> v1 = {
       1, 2, 3, 4, 5};
std::vector<int> v2 = {
       3, 4, 5, 6};
auto it = std::find_first_of(v1.begin(), v1.end(), v2.begin(), v2.end());
```
std::adjacent_find
- 函数原型：template <class ForwardIterator, class BinaryPredicate> ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
- 示例：查找第一个相邻的匹配项
```
std::vector<int> v = {
       1, 2, 3, 2, 4};
auto it = std::adjacent_find(v.begin(), v.end());
```
std::count
- 函数原型：template <class InputIterator, class T> typename iterator_traits<InputIterator>::difference_type count(InputIterator first, InputIterator last, const T& value);
- 示例：计算特定值的出现次数

std::vector<int> v = {
   1, 2, 2, 3, 2, 4};
int count = std::count(v.begin(), v.end(), 2);

std::count_if
- 函数原型：template <class InputIterator, class UnaryPredicate> typename iterator_traits<InputIterator>::difference_type count_if(InputIterator first, InputIterator last, UnaryPredicate pred);
- 示例：计算满足条件的元素数量
```
int count = std::count_if(v.begin(), v.end(), [](int i) {
        return i > 3; });
```
std::mismatch
- 函数原型：template <class InputIterator1, class InputIterator2, class BinaryPredicate> std::pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);
- 示例：查找第一个不匹配的元素对
```
std::vector<int> v1 = {
       1, 2, 3, 4, 5};
std::vector<int> v2 = {
       1, 2, 4, 4, 5};
auto pair = std::mismatch(v1.begin(), v1.end(), v2.begin());
```
std::equal
- 函数原型：template <class InputIterator1, class InputIterator2> bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
- 示例：比较两个范围是否相等
```
std::vector<int> v1 = {
       1, 2, 3, 4, 5};
std::vector<int> v2 = {
       1, 2, 3, 4, 5};
bool is_equal = std::equal(v1.begin(), v1.end(), v2.begin());
```
std::is_permutation
- 函数原型：template <class ForwardIterator1, class ForwardIterator2> bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
- 示例：检查一个范围是否是另一个范围的排列
```
std::vector<int> v1 = {
       1, 2, 3, 4, 5};
std::vector<int> v2 = {
       5, 4, 3, 2, 1};
bool is_perm = std::is_permutation(v1.begin(), v1.end(), v2.begin());
```
std::search
- 函数原型：template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
- 示例：搜索子序列

std::vector<int> v = {
   1, 2, 3, 4, 5};
std::vector<int> pat = {
   3, 4};
auto it = std::search(v.begin(), v.end(), pat.begin(), pat.end());

std::search_n
- 函数原型：template <class ForwardIterator, class Size, class T, class BinaryPredicate> ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred);
- 示例：搜索特定数量的连续元素
```
auto it = std::search_n(v.begin(), v.end(), 3, 2);
```

Modifying sequence operations

std::copy
- 函数原型：template <class InputIterator, class OutputIterator> OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
- 示例&#x