Day 31 C++ STL常用算法（下）

缺点灵气儿2023-08-18 8:17

文章目录

常用拷贝和替换算法

copy------容器内指定范围的元素拷贝到另一容器中

函数原型

  • copy(iterator beg, iterator end, iterator dest);

    // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg 开始迭代器

    // end 结束迭代器

    // dest 目标起始迭代器

注意------利用copy算法在拷贝时，目标容器要提前开辟空间
示例
c++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> source {1, 2, 3, 4, 5};
    std::vector<int> destination(5);  // 提前开辟目标容器空间

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

    // 输出目标容器中的内容
    for (auto i : destination) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：1 2 3 4 5

在上面的示例中，我们首先创建了一个源容器source，其中包含了一些整数。然后，我们创建了一个与源容器相同大小的目标容器destination，并且提前开辟了空间。

接下来，我们使用std::copy算法将源容器中的元素拷贝到目标容器中。通过传递源容器的迭代器source.begin()和source.end()以及目标容器的起始迭代器destination.begin()作为参数，实现了拷贝操作。

最后，遍历目标容器，并打印其中的元素

replace------将容器内指定范围的第一个旧元素修改为新元素

函数原型

  • replace(iterator beg, iterator end, oldvalue, newvalue);

    // 将区间内旧元素 替换成 新元素

    // beg 开始迭代器

    // end 结束迭代器

    // oldvalue 旧元素

    // newvalue 新元素

注意------replace只会替换区间内满足条件的第一个旧元素
示例
c++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

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

    std::replace(vec.begin(), vec.end(), 3, 9);

    // 输出修改后的容器内容
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

1 2 9 4 5

在上面的示例中，我们首先创建了一个整数向量vec，其中包含了一些整数。然后，我们使用std::replace算法将容器中的旧元素3替换为新元素9。

通过传递容器的起始迭代器vec.begin()和结束迭代器vec.end()作为参数，以及要替换的旧元素3和新元素9，实现了替换操作。

最后，我们遍历容器，并打印其中的元素，可以看到被替换的元素已经被修改为新元素。

replace_if------在指定范围内将所有旧元素修改为新元素

函数原型

  • **replace_if(iterator beg, iterator end, _pred, newvalue); **

    // 按条件替换元素，满足条件的替换成指定元素

    // beg 开始迭代器

    // end 结束迭代器

    // _pred 谓词,谓词函数是一个返回布尔值的函数，用于确定元素是否满足某个条件。

    // 注意谓语是返回bool的仿函数，是谓词，是一个类，不是函数，但是可以当函数用

    // 因此可以利用仿函数灵活筛选满足的条件

    // newvalue 替换的新元素

注意------replace会替换区间内满足条件的所有旧元素

示例：

c++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

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

    std::replace_if(vec.begin(), vec.end(), [](int num){ return num == 3; }, 9);

    // 输出修改后的容器内容
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

1 2 9 4 5

在这个示例中，我们使用了一个匿名的lambda函数作为谓词函数来判断元素是否需要被替换。lambda函数接受一个整数参数num，并返回一个bool值，判断这个整数是否等于3。如果等于3，则将其替换为新元素9。

通过使用lambda函数作为谓词函数，我们可以自定义替换的条件。在上述示例中，我们使用等于3的元素作为替换的条件。

需要注意的是，replace_if函数只会替换满足条件的第一个元素，如果想要替换所有满足条件的元素，可以考虑使用std::replace_copy_if或自定义循环进行处理。

swap------互换两个容器的元素

函数原型

  • swap(container c1, container c2);

    // 互换两个容器的元素

    // c1容器1

    // c2容器2

注意------swap交换容器时，注意交换的容器要同种类型

交换不同类型的容器，将会导致编译错误。

类型要匹配

要交换的容器类型要相同，或者满足可以进行隐式转换的条件。例如，两个 std::vector<int> 可以直接交换，但是 std::vector<int> 和 std::vector<double> 之间不能直接交换。

容器的状态

交换容器时，要确保容器处于有效状态，即它们不应被移动、释放或销毁。否则，交换操作可能会导致未定义行为。

迭代器的失效

交换容器后，原来容器中的迭代器将会失效。如果有其他依赖于这些迭代器的代码，则需要谨慎处理，避免使用失效的迭代器。

容器的大小和内存开销

交换容器实际上是交换了它们的内部数据结构，这意味着会涉及到元素的复制或移动操作。如果容器的大小较大，交换操作可能会带来显著的内存开销和性能损失。

异常安全性

交换容器可能会引发异常，因此在交换操作之前，要考虑异常安全性，采取适当的措施来处理异常，以确保程序能够正常执行。

示例
c++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3};
    std::vector<int> vec2 {4, 5, 6};

    swap(vec1, vec2);

    // 输出交换后的vec1
    std::cout << "vec1: ";
    for (auto i : vec1) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // 输出交换后的vec2
    std::cout << "vec2: ";
    for (auto i : vec2) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

vec1: 4 5 6

vec2: 1 2 3

在这个示例中，我们创建了两个vector类型的容器vec1和vec2。

然后，通过调用swap函数来交换这两个容器的元素。最

终，vec1中的元素变成了4, 5, 6，vec2中的元素变成了1, 2, 3。

常用算术生成算法

注意------算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>

accumulate------ 计算区间内容器元素累计总和

函数原型

  • accumulate(iterator beg, iterator end, value);

    // 计算容器元素累计总和

    // beg 开始迭代器

    // end 结束迭代器

    // value 起始值

    //起始值value是可选的，如果不提供该参数，那么默认起始值将是容器中的第一个元素的值。（看下面例子）

注意------如果容器为空，而且没有提供起始值参数，则调用accumulate函数会导致未定义行为

所以，在使用accumulate函数时，建议在累加之前检查容器是否非空，或者提供一个明确的起始值参数。

示例
c++ 复制代码 
#include <iostream>
#include <vector>
#include <numeric>

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

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

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

    return 0;
}

输出结果为：

Sum: 15

在这个示例中，我们调用了accumulate函数来计算容器vec中元素的累计总和，但没有提供起始值参数。由于没有指定起始值，accumulate函数会使用容器中的第一个元素作为起始值进行累加运算。

因此，根据示例中的容器vec，累计总和仍然是15。

fill------用于将指定范围内的元素都设置为给定的值

函数原型

  • fill(iterator beg, iterator end, value);

    // 向容器中填充元素

    // beg 开始迭代器

    // end 结束迭代器

    // value 填充的值

注意------fill函数会将指点范围内所有元素都填充为给定的值，原本已的值会被覆盖。
示例
c++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

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

    std::fill(vec.begin(), vec.end(), 10);

    // 输出填充后的向量
    std::cout << "Filled Vector: ";
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

Filled Vector: 10 10 10 10 10

在这个示例中，我们有一个包含初始值的向量vec，其中包含了数字1到5。然后，我们使用fill函数将容器vec中的所有元素都填充为10。

最终的输出结果显示，原本向量中的元素已经被覆盖，全部变成了10, 10, 10, 10, 10。

因此，需要注意，在使用fill函数时，如果你希望保留原有元素的值，只填充指定范围内的部分元素，可以使用更具灵活性的方法，如迭代器和算法结合使用来实现部分填充。

常用集合算法

set_intersection------求两个容器的交集

set_intersection 函数通常用于计算两个有序集合的交集。

但是，它实际上可以用于任何支持随机访问的序列容器，而不仅限于集合。

函数原型
  • set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器
总结
  • 求交集的两个集合必须是有序序列
  • 目标容器开辟空间需要从两个容器中取小值
  • set_intersection返回值既是交集中最后一个元素的位置

示例：

C++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> intersection(std::min(vec1.size(), vec2.size()));

    auto it = std::set_intersection(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), intersection.begin());

    // 输出交集中的元素
    std::cout << "Intersection: ";
    for (auto i = intersection.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

Intersection: 3 4 5

在这个示例中，我们有两个有序的向量vec1和vec2，分别包含了不同的整数。我们需要找出这两个向量的交集。

首先，我们创建了一个目标容器intersection，它的大小为两个输入容器中较小的那个。

然后，使用set_intersection函数将两个输入容器中的交集复制到目标容器intersection中。set_intersection函数接受五个参数，分别是两个输入容器的起始和结束迭代器，以及目标容器的起始迭代器。这样，交集中的元素就会复制到目标容器中。

最后，我们遍历目标容器中的元素，并输出交集中的值。

set_union------求两个集合的并集

函数原型

  • set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器

总结（和set_intersection差不多）
  • 求并集的两个集合必须的有序序列
  • 目标容器开辟空间需要两个容器相加
  • set_union返回值既是并集中最后一个元素的位置
示例
C++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> unionSet(vec1.size() + vec2.size());

    auto it = std::set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), unionSet.begin());

    // 输出并集中的元素
    std::cout << "Union: ";
    for (auto i = unionSet.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

Union: 1 2 3 4 5 6 7

在这个示例中，我们有两个有序的向量vec1和vec2，分别包含了不同的整数。我们需要找出这两个向量的并集。

首先，我们创建了一个目标容器unionSet，它的大小为两个输入容器的总大小。

然后，使用set_union函数将两个输入容器中的并集复制到目标容器unionSet中。

set_union函数接受五个参数，分别是两个输入容器的起始和结束迭代器，以及目标容器的起始迭代器。这样，并集中的元素就会复制到目标容器中。

最后，我们遍历目标容器中的元素，并输出并集中的值。

set_difference------求两个集合的差集

函数原型

  • set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器

总结（都差不多）
  • 求差集的两个集合必须的有序序列
  • 目标容器开辟空间需要从两个容器取较大值
  • set_difference返回值既是差集中最后一个元素的位置

示例：

C++ 复制代码 
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> difference(std::max(vec1.size(), vec2.size()));

    auto it = std::set_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), difference.begin());

    // 输出差集中的元素
    std::cout << "Difference: ";
    for (auto i = difference.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

Difference: 1 2

在这个示例中，我们有两个有序的向量vec1和vec2，分别包含了不同的整数。我们需要找出这两个向量的差集。

首先，我们创建了一个目标容器difference，它的大小为两个输入容器中较大的那个。

然后，使用set_difference函数将两个输入容器中的差集复制到目标容器difference中。

set_difference函数接受五个参数，分别是两个输入容器的起始和结束迭代器，以及目标容器的起始迭代器。这样，差集中的元素就会复制到目标容器中。

最后，我们遍历目标容器中的元素，并输出差集中的值。

相关推荐
南东山人3 小时前
一文说清：C和C++混合编程
c语言·c++
LNTON羚通4 小时前
摄像机视频分析软件下载LiteAIServer视频智能分析平台玩手机打电话检测算法技术的实现
算法·目标检测·音视频·监控·视频监控
哭泣的眼泪4085 小时前
解析粗糙度仪在工业制造及材料科学和建筑工程领域的重要性
python·算法·django·virtualenv·pygame
Ysjt | 深5 小时前
C++多线程编程入门教程（优质版）
java·开发语言·jvm·c++
ephemerals__5 小时前
【c++丨STL】list模拟实现（附源码）
开发语言·c++·list
Microsoft Word6 小时前
c++基础语法
开发语言·c++·算法
天才在此6 小时前
汽车加油行驶问题-动态规划算法（已在洛谷AC）
算法·动态规划
一只小小汤圆6 小时前
opencascade源码学习之BRepOffsetAPI包 -BRepOffsetAPI_DraftAngle
c++·学习·opencascade
legend_jz6 小时前
【Linux】线程控制
linux·服务器·开发语言·c++·笔记·学习·学习方法
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇