小八博客

Appearance

1.常用遍历算法 ​

1.1 for_each ​

std::for_each 是 C++ 标准模板库中的一个算法，定义在 <algorithm> 头文件中。它接受一个迭代器范围和一个函数对象（仿函数），并对范围内的每个元素执行该函数对象。其语法如下

cpp
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f);
  • first：指向范围的起始位置的迭代器。
  • last：指向范围的末尾位置后一个位置的迭代器。
  • f：要应用于范围中每个元素的函数对象，可以是函数指针、仿函数、lambda 函数等。

该函数返回传入的函数对象 f，以便可以链式调用。

下面是一个简单的示例，演示如何使用 std::for_each 对容器中的每个元素执行一个函数：

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

// 函数对象，用于打印元素
struct Print {
    void operator()(int n) const {
        std::cout << n << " ";
    }
};

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

    // 使用 for_each 对容器中的每个元素执行打印函数
    std::for_each(vec.begin(), vec.end(), Print());

    return 0;
}

在这个示例中，我们定义了一个名为 Print 的函数对象，它重载了 operator()，以便可以被像函数一样调用。然后，我们使用 std::for_each 对容器 vec 中的每个元素执行 Print() 函数对象，从而打印出每个元素。

你也可以使用 lambda 表达式来达到相同的效果，这样可以更加简洁

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

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

    // 使用 lambda 表达式打印容器中的每个元素
    std::for_each(vec.begin(), vec.end(), [](int n) { std::cout << n << " "; });

    return 0;
}

这个 lambda 表达式与之前的 Print 函数对象的功能完全相同，但它更简洁，因为它是内联定义的。

1.2 transform ​

std::transform 是 C++ 标准模板库中的一个算法，用于对一个范围中的每个元素应用给定的操作，并将结果存储到另一个容器中。它接受两个范围（输入范围和输出范围）以及一个表示操作的函数对象（或者函数指针、lambda 表达式等）。其语法如下：

cpp
template<class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform(InputIterator first1, InputIterator last1,
                          OutputIterator result, UnaryOperation op);
  • first1：指向输入范围的起始位置的迭代器。
  • last1：指向输入范围的末尾位置后一个位置的迭代器。
  • result：指向输出范围的起始位置的迭代器。
  • op：要应用于范围中每个元素的操作函数对象。

该函数返回指向输出范围的末尾位置后一个位置的迭代器。

2.常用查找算法 ​

2.1 find ​

std::find 用于在一个迭代器范围内查找与给定值相等的第一个元素。如果找到，则返回指向该元素的迭代器；如果未找到，则返回一个指向范围结束的迭代器。

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

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

    auto it = std::find(data.begin(), data.end(), 3);
    if (it != data.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "3 not found in the vector." << std::endl;
    }

    return 0;
}

2.2 find_if ​

std::find_if 用于在一个迭代器范围内查找满足特定条件（由谓词定义）的第一个元素。它允许更复杂的查找条件，而不仅仅是等于操作。

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

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

    auto is_odd = [](int x) { return x % 2 != 0; };
    auto it = std::find_if(data.begin(), data.end(), is_odd);
    if (it != data.end()) {
        std::cout << "First odd number: " << *it << std::endl;
    }

    return 0;
}

2.3 adjacent_find ​

std::adjacent_find 用于查找迭代器范围内的第一对相邻重复元素。如果找到，则返回指向第一个这样的元素的迭代器；如果未找到，返回范围结束的迭代器。

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

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

    auto it = std::adjacent_find(data.begin(), data.end());
    if (it != data.end()) {
        std::cout << "First adjacent pair: " << *it << std::endl;
    }

    return 0;
}

2.4 binary_search ​

std::binary_search 用于检查在已排序的迭代器范围内是否存在某个元素。它返回一个布尔值，表示是否找到该元素。

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

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

    if (std::binary_search(data.begin(), data.end(), 3)) {
        std::cout << "3 exists in the vector." << std::endl;
    } else {
        std::cout << "3 does not exist." << std::endl;
    }

    return 0;
}

2.5 count ​

std::count 用于计算给定值在迭代器范围内出现的次数。

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

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

    int count_of_twos = std::count(data.begin(), data.end(), 2);
    std::cout << "Number of 2s: " << count_of_twos << std::endl;

    return 0;
}

2.6 count_if ​

std::count_if 类似于 std::count，但它计算满足特定条件（由谓词定义）的元素的数量

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

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 定义一个谓词函数，用于检查元素是否为偶数
    auto is_even = [](int x) { return x % 2 == 0; };

    // 使用 count_if 计算偶数的数量
    int count_even = std::count_if(data.begin(), data.end(), is_even);
    std::cout << "Number of even elements: " << count_even << std::endl;

    return 0;
}

3.常用排序算法 ​

3.1 sort ​

std::sort 是 C++ 标准模板库中最常用的排序算法之一。它用于对容器中的元素进行排序，默认情况下是升序排序。

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

int main() {
    std::vector<int> data = {3, 1, 4, 1, 5, 9, 2, 6, 5};

    std::sort(data.begin(), data.end());

    std::cout << "Sorted data:";
    for (int num : data) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

3.2 random_shuffle ​

std::random_shuffle 可以用来对容器中的元素进行随机排列。

cpp
#include <algorithm>
#include <vector>
#include <iostream>
#include <ctime> // 需要包含头文件 <ctime> 来使用 std::time

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

    // 使用当前时间作为随机数生成器的种子
    std::srand(static_cast<unsigned int>(std::time(nullptr)));

    std::random_shuffle(data.begin(), data.end());

    std::cout << "Shuffled data:";
    for (int num : data) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

3.3 merge ​

std::merge 用于将两个已排序的序列合并为一个已排序的序列

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

int main() {
    std::vector<int> data1 = {1, 3, 5, 7, 9};
    std::vector<int> data2 = {2, 4, 6, 8, 10};

    std::vector<int> merged(10); // 结果存放的向量

    std::merge(data1.begin(), data1.end(), data2.begin(), data2.end(), merged.begin());

    std::cout << "Merged data:";
    for (int num : merged) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

3.4 reverse ​

std::reverse 用于将容器中的元素进行反转。

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

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

    std::reverse(data.begin(), data.end());

    std::cout << "Reversed data:";
    for (int num : data) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

4.常用拷贝替换算法 ​

4.1 copy ​

std::copy 用于将一个范围内的元素拷贝到另一个范围中。

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

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

    std::copy(source.begin(), source.end(), destination.begin());

    std::cout << "Copied data:";
    for (int num : destination) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

4.2 replace ​

std::replace 用于将容器中的所有指定值替换为另一个值

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

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

    std::replace(data.begin(), data.end(), 2, 0);

    std::cout << "Replaced data:";
    for (int num : data) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

4.3 replace_if ​

std::replace_if 用于将容器中满足指定条件的所有元素替换为另一个值。

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

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

    // 将所有偶数替换为 0
    std::replace_if(data.begin(), data.end(),
                    [](int x) { return x % 2 == 0; }, 0);

    std::cout << "Replaced data:";
    for (int num : data) {
        std::cout << " " << num;
    }
    std::cout << std::endl;

    return 0;
}

4.4 swap ​

std::swap 用于交换两个对象的值。

cpp
#include <algorithm>
#include <iostream>

int main() {
    int a = 1, b = 2;
    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;

    std::swap(a, b);

    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}

5.常用算数生成算法 ​

5.1 accumulate ​

std::accumulate 用于计算容器中元素的累加值。

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

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

    int sum = std::accumulate(data.begin(), data.end(), 0);

    std::cout << "Sum of elements: " << sum << std::endl;

    return 0;
}

5.2 fill ​

std::fill 算法用于将指定范围内的所有元素设置为给定值。其函数原型如下

cpp
template< class ForwardIt, class T >
void fill( ForwardIt first, ForwardIt last, const T& value );
  • first：指向范围的起始位置的迭代器。
  • last：指向范围的末尾位置后一个位置的迭代器。
  • value：要填充的值。

std::fill 会将范围 [first, last) 中的所有元素都设置为 value。

6.常用集合算法 ​

6.1 set_intersection(交集) ​

std::set_intersection 算法用于计算两个有序集合的交集，并将结果存储在输出迭代器指定的范围内。这个算法要求两个输入范围都是已排序的。

cpp
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_intersection(InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first );

6.2 set_union(并集) ​

6.3 set_difference(差集) ​

评论区

欢迎留言、补充或勘误。

xiaoba.blog

Copyright © 2023-2026 小八