C++常用排序&拷贝&替换&算术生成&集合运算算法总结

已于 2024-07-10 18:55:17 修改
阅读量1k 收藏 8
点赞数 12
分类专栏： C/C++编程基础 文章标签： c++ 算法 开发语言
于 2024-07-10 18:53:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_73497355/article/details/140331825
版权

文章目录

1.常用排序算法

在C++中，排序和相关操作是非常实用的功能。

1. sort

sort函数是C++标准库提供的一个强大的排序算法，它能够对容器（如std::vector、std::list、std::deque等）或数组中的元素进行排序。默认情况下，它执行升序排序，但也可以通过提供自定义比较函数来进行降序或其他定制排序。sort位于<algorithm>头文件中。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// 主函数，程序的入口点
int main(){
    // 初始化一个整数向量，包含一组待排序的数字
    vector<int>v = {1,3,2,6,5,7,4};

    // 对向量进行升序排序
    sort(v.begin(), v.end());

    // 遍历并打印排序后的向量
    for(int n : v){
        cout << n << " ";
    }
    cout << endl;

    // 对向量进行降序排序
    sort(v.begin(), v.end(),[](int &a,int &b){return a > b;});

    // 再次遍历并打印排序后的向量
    for(int n : v){
        cout << n << " ";
    }

    return 0;
}
2. random_shuffle

random_shuffle函数用于将容器中的元素随机重新排列。不过需要注意的是，在C++14之后，random_shuffle已经被标记为已弃用，推荐使用shuffle函数，它提供了更好的随机性控制。random_shuffle同样位于<algorithm>头文件中。

基本用法示例 :

//
// Created by 86189 on 2024/7/10.
//
#include <iostream>
#include <algorithm>
#include <vector>
#include <random>
using namespace std;

/* 主函数 */
int main(){
    /* 初始化一个整数向量，包含一组数字 */
    vector<int>v = {1,9,6,4,5,3,5};

    /* 初始化一个随机设备，用于生成随机数种子 */
    random_device rd;

    /* 使用Mersenne Twister算法初始化随机数生成器 */
    mt19937 g(rd());

    /* 使用随机数生成器对向量进行洗牌操作，以打乱其元素顺序 */
    shuffle(v.begin(), v.end(), g);

    /* 遍历并输出洗牌后的向量元素 */
    for(int n : v) cout << n << " ";

    return 0;
}
3. merge

merge函数用于合并两个已排序的序列，将它们合并成一个新的有序序列。这通常与sort配合使用于更复杂的排序算法中，如归并排序。它同样位于<algorithm>头文件中。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// 主函数，演示如何使用标准库函数merge合并两个有序向量
int main(){
    // 初始化两个有序向量v1和v2
    vector<int>v1 = {1,3,5};
    vector<int>v2 = {2,4,6};

    // 初始化一个足够大的向量v3用于存放合并后的结果
    // 其大小为v1和v2的大小之和
    vector<int>v3(v1.size()+v2.size());

    // 调用标准库函数merge将v1和v2合并到v3中
    // 这里的merge函数假设输入的两个向量v1和v2是有序的
    // 合并后的向量v3仍然保持有序
    merge(v1.begin(), v1.end(),v2.begin(), v2.end(),v3.begin());

    // 遍历并打印合并后的向量v3
    for(int n : v3) cout << n << " ";

    return 0;
}
4. reverse

reverse函数用于反转容器或数组中元素的顺序。它同样简单易用，只需提供起始和结束迭代器即可。此函数也在<algorithm>头文件中定义。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// 主函数，程序的入口点
int main() {
    // 初始化一个整数向量v1，包含元素1, 3, 5
    vector<int> v1 = {1, 3, 5};

    // 翻转向量v1中的元素顺序
    reverse(v1.begin(), v1.end());

    // 遍历并打印翻转后的向量v1中的每个元素
    for(int n : v1) cout << n << " ";

    return 0;
}

2.常用拷贝和替换算法

在C++中，常用的拷贝和替换算法是处理容器或数组元素时非常基础且重要的操作。

1. copy

copy函数用于将一个范围内的元素复制到另一个范围内。这个函数位于<algorithm>头文件中。

基本用法示例:

// 包含标准库的头文件，用于输入输出和算法操作
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

// 程序的入口点
int main() {
    // 初始化源向量，包含一组整数
    vector<int> src = {1, 2, 3, 4};

    // 初始化目标向量，大小与源向量相同
    vector<int> dest(4);

    // 将源向量的内容复制到目标向量
    // 使用标准库算法copy进行复制操作
    copy(src.begin(), src.end(), dest.begin());

    // 遍历目标向量并打印每个元素
    // 用于展示复制操作的结果
    for(int n : dest) cout << n << " ";

    // 程序正常结束
    return 0;
}
2. replace

replace函数用于在给定范围内查找指定的旧值，并将其替换为新值。它也位于<algorithm>头文件中。

基本用法示例:

#include <algorithm> // 包含算法库，用于使用replace函数
#include <iostream> // 包含输入输出流，用于标准输出
#include <vector> // 包含向量容器，用于存储和操作整数序列
using namespace std;

int main() {
    vector<int> src = {1, 2, 3, 4}; // 初始化一个整数向量，包含1, 2, 3, 4

    // 使用replace函数将向量src中所有的2替换为99
    // replace函数的作用是：在给定的范围内，找到所有与目标值相同的元素，并将其替换为新值
    replace(src.begin(), src.end(), 2, 99);

    // 遍历向量src，并打印每个元素
    // 这里使用范围for循环来遍历向量，展示replace操作后的结果
    for(int n : src) cout << n << " ";

    return 0; // 程序正常退出
}
3. replace_if

replace_if函数类似于replace，但它不是直接匹配值，而是基于谓词（一个返回bool值的函数或函数对象）来决定是否进行替换。当谓词对元素返回true时，该元素会被替换。

基本用法示例:

#include <algorithm> // 使用标准库的算法
#include <iostream> // 使用标准库的输入输出流
#include <vector> // 使用标准库的向量容器
using namespace std;

// 主函数，程序的入口点
int main() {
    // 初始化一个整数向量，包含1到4
    vector<int> src = {1, 2, 3, 4};

    // 使用replace_if算法替换向量中所有满足条件的元素
    // 条件是元素值为偶数，将其替换为99
    replace_if(src.begin(), src.end(), [](int n){return n%2==0;}, 99);

    // 遍历向量并打印每个元素
    for(int n : src) cout << n << " ";

    return 0; // 程序正常结束
}
4. swap

swap函数用于交换两个对象的值。它可以用于内置类型，也可以用于自定义类型（只要这些类型重载了swap函数或遵循移动语义）。对于标准库容器，可以直接调用它们的swap成员函数，或者使用std::swap函数，它位于<utility>头文件中。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

// 主函数，程序的入口点
int main() {
    // 初始化源向量
    vector<int> src = {1, 2, 3, 4};

    // 初始化目标向量
    vector<int> dest = {7,6,8,5,3,4};

    // 交换源向量和目标向量的内容
    // 说明：这里使用swap函数来交换两个向量的内容，目的是为了展示向量内容的交换过程
    swap(src, dest);

    // 遍历并打印源向量的内容
    for (int n : src) cout << n << " ";
    cout << endl;

    // 遍历并打印目标向量的内容
    for (int n : dest) cout << n << " ";

    return 0;
}

这些算法极大地简化了在C++中处理数据集合的任务，提高了代码的可读性和效率。

3.常用算术生成算法

在C++中，除了拷贝和替换算法外，算术生成算法也是处理数据集合时经常使用的工具。

1. accumulate

accumulate函数用于计算一系列数值的总和（累积和）。此函数位于<numeric>头文件中，可以接受一个初始值作为累积和的起始点。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;

// 主函数，程序的入口点
int main(){
    // 初始化一个整数向量v，包含一组预设的整数
    vector<int>v = {1,10,2,3,5};

    // 使用accumulate函数对向量v中的所有元素进行累加，初始值为0
    // accumulate函数是标准库中用于累加的算法，这里展示了其在向量操作中的应用
    int sum = accumulate(v.begin(), v.end(),0);

    // 输出累加结果
    cout << sum << endl;

    // 程序正常结束
    return 0;
}
2. fill

fill算法用于将一个范围内所有元素赋值为某个特定的值。它同样位于<algorithm>头文件中。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

// 主函数，程序的入口点
int main() {
    // 初始化一个长度为10的整数向量，所有元素初始值为0
    vector<int> vec(10, 0);

    // 使用标准库函数fill将向量的所有元素赋值为7
    fill(vec.begin(), vec.end(), 7);

    // 遍历向量并打印每个元素
    for(int num : vec)
        cout << num << " ";
    return 0;
}

这两个算法在处理数值集合时非常有用，accumulate用于求和运算，而fill则用于快速设置一系列值，比如初始化数组或向量等。

4.常用集合算法

集合算法在C++标准库中的<algorithm>头文件里定义，它们主要用于处理集合（如数组、向量等容器）之间的数学集合操作。

1. set_intersection

set_intersection算法用于找出两个已排序的集合的交集，并将结果存放到另一个集合中。集合需要是有序的，且不能有重复元素。

基本用法示例:

// 包含必要的头文件
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;

// 主函数
int main(){
    // 初始化两个集合，分别包含一组整数
    set<int>s = {1,2,3,4,5,6};
    set<int>s1 = {2,4,6,8,10};

    // 初始化一个向量，用于存储两个集合的交集元素
    // 其大小预先估计为两个集合元素总数之和
    vector<int>v(s.size()+s1.size());

    // 使用set_intersection算法计算两个集合的交集
    // 并将结果存储在向量v中
    auto it = set_intersection(s.begin(), s.end()
            ,s1.begin(), s1.end(),
                        v.begin());

    // 调整向量的大小，以去除多余的未使用的空间
    // 它的大小现在等于交集中实际元素的数量
    v.resize(it - v.begin());

    // 遍历并打印向量中的元素，即两个集合的交集
    for(int n : v) cout << n << " ";

    // 程序正常退出
    return 0;
}
2. set_union

set_union算法用于合并两个已排序的集合，去除重复元素，得到并集，并将结果存放到另一个集合中。

基本用法示例:

// 包含必要的头文件
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;

// 主函数
int main(){
    // 初始化两个集合，分别包含一组不重复的整数
    set<int>s = {1,2,3,4,5,6};
    set<int>s1 = {2,4,6,8,10};
    
    // 初始化一个向量，大小为两个集合元素总数，用于存储合并后的结果
    vector<int>v(s.size()+s1.size());
    
    // 使用set_union算法将两个集合的元素合并到向量v中，重复的元素只出现一次
    // set_union算法返回一个迭代器，指向向量v中第一个未被写入的元素
    auto it = set_union(s.begin(), s.end()
    ,s1.begin(), s1.end(),
    v.begin());
    
    // 根据返回的迭代器调整向量v的大小，使其正好包含所有合并后的元素
    v.resize(it - v.begin());

    // 遍历向量v，输出合并后的所有元素
    for(int n : v) cout << n << " ";

    return 0;
}
3. set_difference

set_difference算法用于找出两个已排序的集合的差集，即第一个集合中存在但第二个集合中不存在的元素，并将结果存放到另一个集合中。

基本用法示例:

//
// Created by 86189 on 2024/7/10.
//
//

#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;

// 主函数
int main(){
    // 初始化两个集合，分别包含一组整数
    set<int>s = {1,2,3,4,5,6};
    set<int>s1 = {2,4,6,8,10};

    // 初始化一个向量，用于存储两个集合的差集结果
    vector<int>v(s.size()+s1.size());

    // 使用std::set_difference算法计算两个集合的差集
    // 并将结果写入向量v中
    auto it = set_difference(s.begin(), s.end()
            ,s1.begin(), s1.end(),
                               v.begin());

    // 调整向量的大小，使其正好包含所有差集元素
    v.resize(it - v.begin());

    // 遍历并输出向量中的差集元素
    for(int n : v) cout << n << " ";

    return 0;
}

这些算法都要求输入序列是预先排序的，并且对于set_intersection和set_difference来说，如果输入序列中有重复元素，结果只包含每个不同元素的一个实例。

数组查找及替换c++题解
Cjeiwnsjc的博客
01-02 645
题目描述 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入格式 第一行为数组元素个数和整数b 第二行为数组各个元素 输出格式 按照要求输出 样例输入 7 2 77 11 66 22 44 33 55 样例输出 11 33 55 M
#854. 【入门】数组查找及替换
XTX54188的博客
02-04 700
给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。第一行为数组元素个数和整数b。【来源】蓝桥杯算法训练。第二行为数组各个元素。
C语言/C++数组替换【简单易懂，代码可以直接运行】
于笨笨的博客
10-06 3992
C语言/C++数组替换【简单易懂，代码可以直接运行】 输入一个长度为 10 的整数数组 X[10]，将里面的非正整数全部替换为 1，输出替换完成后的数组。 输入格式 输入包含 10 个整数，每个整数占一行。 输出格式 输出新数组中的所有元素，每个元素占一行。 输出格式为 X[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。 数据范围 −100≤X[i]≤100 难度为简单，代码如下： #include&lt;iostream&gt; #include&lt;cstring&gt; usi
C++之，我是如何解决数据查找与替换难题的
最新发布
wj_rdk的博客
03-02 830
在C++编程的世界里，数据查找与替换是极为常见的操作，却也是让我在项目开发过程中颇费周折的难题。今天，就和大家唠唠我在这方面遇到的挑战以及解决之道。
爪哇oj--数组查找及替换
枠成
01-29 424
以此纪念优快云的第一篇博客，感谢满满师姐的鼓励 数组查找及替换 Description 给定某整数数组和某一整数b。 要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。 如果数组元素数值在A到Z的ASCII之间，替换为对应字母。 元素个数不超过100，b在1至100之间。 Input 输入描述:　　 第一行为数组元素个数和整数b 　　 第二行为数...
【C++ 二十】STL：遍历、查找、排序、拷贝和替换、算术生成、集合算法
qq_45138120的博客
04-22 869
本文包含STL常用遍历算法（for_each、transform）、STL常用查找算法（find、find_if、adjacent_find、binary_search、count、count_if）、STL常用排序算法（sort、random_shuffle、merge、reverse）、STL常用拷贝和替换算法（copy、replace、replace_if、swap）、STL常用算术生成算法（accumulate、fill）、STL常用集合算法（set_intersection、set_union、s
C++ STL常用算法 学习总结
weixin_45231931的博客
02-17 645
end1 容器1结束迭代器 beg2 容器2开始迭代器 end2 容器2结束迭代器 dest 目标容器开始迭代器。beg1 容器1开始迭代器，end1 容器1结束迭代器，beg2 容器2开始迭代器，end2 容器2结束迭代器。beg 开始迭代器，end 结束迭代器，oldvalue 旧元素，newvalue 新元素。beg 开始迭代器，end 结束迭代器，_Pred 谓词，newvalue 替换的新元素。查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
C++ 常用算法
Jacker优快云的博客
07-04 1059
C++ STL的一些常用的算法：遍历、增删改查、拷贝、替换、算术生成、求交集、并集和差集等
C++ STL 常用算法详解：遍历、查找、排序与更多
&quot;这篇文档介绍了C++ STL中的常用算法，包括遍历、查找、排序、拷贝、替换和算术生成等操作。这些算法主要涉及`&lt;algorithm&gt;`、`&lt;functional&gt;`和`&lt;numeric&gt;`三个头文件。&quot; 在C++ STL（标准模板库）中，算法是一组强大...
【C++】：STL容器总结以及算法（algorithm）介绍
yuanCruise
06-14 2702
容器的共通能力 所有容器提供的都是值（value）语意，而非引用（reference）语意。容器执行插入元素的操作时，内部实施拷贝动作。所以STL容器内存储的元素必须能够被拷贝（必须提供拷贝构造函数）。 除了queue与stack外，每个容器都提供可返回迭代器的函数，运用返回的迭代器就可以访问元素。 通常STL不会丢出异常。要求使用者确保传入正确的参数。 每个容器都提供了一个默认构造函数跟一个...
【东方博宜】【入门】1858--数组查找及替换
LAN_CIKR的博客
12-20 1729
题目描述 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入 第一行为数组元素个数和整数b 第二行为数组各个元素 输出 按照要求输出 样例 输入 7 2 77 11 66 22 44 33 55 输出 11 33 55 M 码来! #include&lt;bits/stdc++.h&gt; using namespace.
【C++】数组操作
ZoomToday
06-27 2754
基本原理：模板类vector是一种动态数组，可以在运行阶段设置vector对象的长度，可以在末尾附加新数据，还可以在中间插入新数据。基本上，它是使用new创建动态数组的替代品。实际上，vector类使用new和delete来管理内存，这个工作是自动完成的。 首先，要使用vector，必须包含头文件vector；其次，vector包含在名称空间std中；第三，模板使用不同的语法来指出他存储的数据类型；第四，vector类使用不同的语法来指定元素数。 vector类的功能比数组强大，但付出的代价是效率较低。如果
C++：STL：常用算法（下）：拷贝，算术，集合算法
C++ JAVA的专栏
01-04 676
C++：STL：常用算法（下）：拷贝，算术，集合算法
C++动态数组vector（增删查改）
Android小码家
08-31 2762
前言： 这里做了比较全面的vector的增删查改操作，以及加入对象,可以理解为JAVA的Collection类，只是API的定义名称有差异而已。 Maqi对象： #include &amp;lt;iostream&amp;gt; #include &amp;lt;cstring&amp;gt; using namespace std; class Human { public: int weight; ...
Java 数组查找及替换
a215012954的博客
01-23 5371
问题描述 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入格式 第一行为数组元素个数和整数b 　　第二行为数组各个元素 输出格式 按照要求输出 样例输入 7 2 77 11 66 22 44 33 55 样例输出 11 33 55 M 代码...
【C++】C++中查找并替换字符串中的特定单个字符、多个字符、中文字符
qq_35902025的博客
07-25 6608
请注意，如果字符串中没有要替换的字符， std::replace 不会执行任何操作，因此这两个方法在这种情况下都是高效的。如果你需要替换的字符在字符串中不存在，使用 std::replace 的方法会稍微更快一些，因为它内部优化了查找和替换的过程。此外， std::string::find 和 std::string::replace 函数在处理多字节字符时可能会有些复杂，因为它们可能不会正确识别多字节字符的边界。std::replace 是C++标准库中的一个函数，可以替换字符串中的字符。
C语言 · 数组查找及替换
weixin_34408624的博客
02-15 2130
算法训练 数组查找及替换   时间限制：1.0s   内存限制：512.0MB      问题描述 　　给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入格式 　　第一行为数组元素个数和整数b　　第二行为数组各个元素 输出格式 　　按照要...
算法训练 数组查找及替换
程序员伤不起
01-29 1048
思路：给你一组数和一个数b，将它们当中能够整除b的数去除掉，并将去除后剩余的数进行排序，然后将排好的数输出，这里要注意的是如果有ASCII正好在65到90之间的就将它们按照大写字母输出（这里用到了强制类型转换） 不多说了上代码： #include #include #include #include #include #include #include using namespace std;
蓝桥杯练习题——数组查找与替换以及快速排序的用法
qq_45533673的博客
01-31 763
蓝桥杯练习题——数组查找与替换 以及快速排序（常用排序方法的一种）的用法 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入描述: 　　第一行为数组元素个数和整数b 　　第二行为数组各个元素 这道题按照要求可以分为三步： 1.找到被b整除的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FightingLod

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值