STL常见算法

最新推荐文章于 2024-08-27 11:04:06 发布
最新推荐文章于 2024-08-27 11:04:06 发布
阅读量1.4k 收藏 3
点赞数 1
分类专栏： STL算法 文章标签： STL 通用算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asd1230123dsa/article/details/85718299
版权

这么长时间过去了，一点点的总算将STL中常见的算法看完了，是时候总结一下了。

一、for_each,允许对区间内的元素进行修改

二、元素计数

  1. difference_type count (InputIterator beg, InputIterator end, const T& value);
  2. difference_type count_if (InputIterator beg, InputIterator end, UnaryPredicate op)；

三 、查找

  1. InputIterator find (InputIterator beg, InputIterator end, const T& value);
  2. InputIterator find_if (InputIterator beg, InputIterator end, UnaryPredicate op);
  3. InputIterator find_if_not (InputIterator beg, InputIterator end, UnaryPredicate op)
  4. ForwardIterator1 search (ForwardIterator1 beg, ForwardIterator1 end,ForwardIterator2 searchBeg, ForwardIterator2 searchEnd);//查找beg-end区间内与第二个区间完全一致的子区间，返回查找到子区间的第一个元素的位置。
  5. ForwardIterator1 search (ForwardIterator1 beg, ForwardIterator1 end,ForwardIterator2 searchBeg, ForwardIterator2 searchEnd,BinaryPredicate op);//查找beg-end区间内与第二个区间完全一致的子区间，返回查找到子区间的第一个元素的位置。
  6. InputIterator find_first_of (InputIterator beg, InputIterator end,ForwardIterator searchBeg, ForwardIterator searchEnd);
  7. InputIterator find_first_of (InputIterator beg, InputIterator end,ForwardIterator searchBeg, ForwardIterator searchEnd,BinaryPredicate op);//查找某些元素第一次出现的地点
  8. ForwardIterator adjacent_find (ForwardIterator beg, ForwardIterator end);
  9. ForwardIterator adjacent_find (ForwardIterator beg, ForwardIterator end,BinaryPredicate op);//查找两个连续且相等的元素。

四、非更易型算法

     1. bool equal (InputIterator1 beg, InputIterator1 end,InputIterator2 cmpBeg);

     2. bool equal (InputIterator1 beg, InputIterator1 end,InputIterator2 cmpBeg,BinaryPredicate op);//校验两个区间是否相等

     3. bool is_permutation (ForwardIterator1 beg1, ForwardIterator1 end1,ForwardIterator2 beg2);

     4. bool is_permutation (ForwardIterator1 beg1, ForwardIterator1 end1,ForwardIterator2 beg2,CompFunc op);//检测两个区间，在不考虑数序的的情况下的相等性。

     5. pair<InputIterator1,InputIterator2>mismatch (InputIterator1 beg, InputIterator1 end,InputIterator2 cmpBeg);

     6. pair<InputIterator1,InputIterator2>mismatch (InputIterator1 beg, InputIterator1 end,InputIterator2 cmpBeg,BinaryPredicate op);//返回两个区间内第一个不同的元素组成的pair。如果都相同则返回两个区间内最后一个元素组成的pair。

     7. bool lexicographical_compare (InputIterator1 beg1, InputIterator1 end1,InputIterator2 beg2, InputIterator2 end2);

     8. bool lexicographical_compare (InputIterator1 beg1, InputIterator1 end1,InputIterator2 beg2,InputIterator2 end2,CompFunc op);//以字典顺序，比较两个区间，第一个用“<”比较，第二种使用op比较。

    9. bool is_sorted(ForwardIterator beg, ForwardIterator end);

    10.bool is_sorted (ForwardIterator beg, ForwardIterator end, BinaryPredicate op);//检测一个区间是否是有序的，如果区间内只有一个元素或者没有元素都返回真。

    11. ForwardIterator is_sorted_until (ForwardIterator beg, ForwardIterator end);

    12. ForwardIterator is_sorted_until (ForwardIterator beg, ForwardIterator end, BinaryPredicate op);//如果区间是无序的则返回第一个破坏顺序位置，否则返回end。

    13. bool is_partitioned (InputIterator beg, InputIterator end, UnaryPredicate op);//返回一个区间是否被切割，切割的意思就是所有使op返回true的元素都在返回false的元素之前。

    14. ForwardIterator partition_point (ForwardIterator beg, ForwardIterator end, BinaryPredicate op);//返回切割后的第一个元素的位置。

    15. bool all_of (InputIterator beg, InputIterator end, UnaryPredicate op);

    16. bool any_of (InputIterator beg, InputIterator end, UnaryPredicate op);

    17. bool none_of (InputIterator beg, InputIterator end, UnaryPredicate op);

五、更易型算法

OutputIterator copy (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg);

OutputIterator copy_if (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg,UnaryPredicate op);

OutputIterator copy_n (InputIterator sourceBeg,Size num,OutputIterator destBeg);

BidirectionalIterator2 copy_backward (BidirectionalIterator1 sourceBeg,BidirectionalIterator1 sourceEnd,BidirectionalIterator2 destEnd);

OutputIterator  transform (InputIterator1 source1Beg, InputIterator1 source1End,OutputIterator destBeg,BinaryFunc op);

OutputIterator transform (InputIterator1 source1Beg, InputIterator1 source1End,InputIterator2 source2Beg,OutputIterator destBeg,BinaryFunc op);

ForwardIterator2 swap_ranges (ForwardIterator1 beg1, ForwardIterator1 end1,ForwardIterator2 beg2)；

void fill (ForwardIterator beg, ForwardIterator end,const T& newValue)

void fill_n (OutputIterator beg, Size num,const T& newValue)

void generate (ForwardIterator beg, ForwardIterator end,Func op)

void generate_n (OutputIterator beg, Size num,Func op)；

void iota (ForwardIterator beg, ForwardIterator end,T startValue)；//卧槽 这个傻逼函数我觉的有必要记下

int main()
{
    array<int,10> coll;
    iota (coll.begin(), coll.end(),42); 
    PRINT_ELEMENTS(coll,"coll: ");
}
//The program has the following output:
//coll: 42 43 44 45 46 47 48 49 50 51

void replace (ForwardIterator beg, ForwardIterator end,const T& oldValue, const T& newValue)

void replace_if (ForwardIterator beg, ForwardIterator end,UnaryPredicate op, const T& newValue)

OutputIterator replace_copy (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg,const T& oldValue, const T& newValue）

OutputIterator replace_copy_if (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg,UnaryPredicate op, const T& newValue)

 

 

ForwardIterator remove (ForwardIterator beg, ForwardIterator end,const T& value)

ForwardIterator remove_if (ForwardIterator beg, ForwardIterator end,UnaryPredicate op)

 

OutputIterator remove_copy (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg,const T& value)

OutputIterator remove_copy_if (InputIterator sourceBeg, InputIterator sourceEnd,

OutputIterator destBeg,UnaryPredicate op)

ForwardIterator unique (ForwardIterator beg, ForwardIterator end)

ForwardIterator unique (ForwardIterator beg, ForwardIterator end,BinaryPredicate op)

 

void reverse (BidirectionalIterator beg, BidirectionalIterator end)

OutputIterator reverse_copy (BidirectionalIterator sourceBeg, BidirectionalIterator sourceEnd,OutputIterator destBeg)

ForwardIterator rotate (ForwardIterator beg, ForwardIterator newBeg, ForwardIterator end)

OutputIterator rotate_copy (ForwardIterator sourceBeg, ForwardIterator newBeg,ForwardIterator sourceEnd,OutputIterator destBeg)//旋转

bool next_permutation (BidirectionalIterator beg, BidirectionalIterator end)

bool next_permutation (BidirectionalIterator beg, BidirectionalIterator end,BinaryPredicate op)

bool prev_permutation (BidirectionalIterator beg, BidirectionalIterator end)

bool prev_permutation (BidirectionalIterator beg, BidirectionalIterator end,BinaryPredicate op)

这个有点难理解，首先需要先明白什么是字典序，比如说我们有1,2,3三个数，按字典序排序，序列就是123,132,213,231,312,321，所以当使用next_permutation操作132时，得到的将是213，如果是prev_permutation操作312得到的将是231。可以使用该函数排序，但是效率真的差到没朋友，所以非常不建议使用该方法排序。

 

//重排序

void shuffle (RandomAccessIterator beg, RandomAccessIterator end,UniformRandomNumberGenerator&& eng)

void random_shuffle (RandomAccessIterator beg, RandomAccessIterator end)

void random_shuffle (RandomAccessIterator beg, RandomAccessIterator end,RandomFunc&& op)

//stable 的意思是稳定的，partition划分。将使OP返回true的元素移到区间的前部

ForwardIterator partition (ForwardIterator beg, ForwardIterator end,UnaryPredicate op)

BidirectionalIterator stable_partition (BidirectionalIterator beg, BidirectionalIterator end,UnaryPredicate op)

pair<OutputIterator1,OutputIterator2> partition_copy (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator1 destTrueBeg, OutputIterator2 destFalseBeg,UnaryPredicate op)

//不能对list和forward_list使用，因为它们两个没有提供随机访问迭代器

//复杂度 nlog(n)

 

void sort (RandomAccessIterator beg, RandomAccessIterator end)//排序

void sort (RandomAccessIterator beg, RandomAccessIterator end, BinaryPredicate op)

 

//如果内存充足，复杂度也是nlog(n) 否则是nlog（n） * log(n)

void stable_sort (RandomAccessIterator beg, RandomAccessIterator end)

void stable_sort (RandomAccessIterator beg, RandomAccessIterator end,BinaryPredicate op)

 

//局部排序复杂度在线性与nlog(n)之间

void partial_sort (RandomAccessIterator beg, RandomAccessIterator sortEnd,RandomAccessIterator end)

void partial_sort (RandomAccessIterator beg, RandomAccessIterator sortEnd,RandomAccessIterator end, BinaryPredicate op)

RandomAccessIterator partial_sort_copy (InputIterator sourceBeg, InputIterator sourceEnd,RandomAccessIterator destBeg, RandomAccessIterator destEnd)

RandomAccessIterator partial_sort_copy (InputIterator sourceBeg, InputIterator sourceEnd,RandomAccessIterator destBeg, RandomAccessIterator destEnd,BinaryPredicate op)

 

//只保证nth前面的比nth小，后面的比nth大，不保证相对顺序，但是在有些编译器中结果也是全排列的，但是千万不要依赖该特性，如果真的要全排序的话请使用sort函数，或者partial_sort

void nth_element (RandomAccessIterator beg, RandomAccessIterator nth,RandomAccessIterator end)

void nth_element (RandomAccessIterator beg, RandomAccessIterator nth,RandomAccessIterator end, BinaryPredicate op)

 

堆算法：

bool is_heap (RandomAccessIterator beg, RandomAccessIterator end);

RandomAccessIterator is_heap_until (RandomAccessIterator beg, RandomAccessIterator end);//返回第一个使区间不再是heap的元素的位置。

void make_heap (RandomAccessIterator beg, RandomAccessIterator end)

void make_heap (RandomAccessIterator beg, RandomAccessIterator end,BinaryPredicate op)

//该算法是将区间内的最后一个元素添加到heap中，所以调用中必须确保beg~end-1已经是一个heap

void push_heap (RandomAccessIterator beg, RandomAccessIterator end)

void push_heap (RandomAccessIterator beg, RandomAccessIterator end,BinaryPredicate op)

//pop出堆中第一个元素（最大的），将最大的元素移动到最后一个位置，并且将剩下的元素组织成一个新的heap，同样调用该函数之前必须确保beg-end区间就是一个heap

void pop_heap (RandomAccessIterator beg, RandomAccessIterator end)

void pop_heap (RandomAccessIterator beg, RandomAccessIterator end,BinaryPredicate op)

//对heap进行排序，从此之后beg-end区间将不再是一个heap

void sort_heap (RandomAccessIterator beg, RandomAccessIterator end)

void sort_heap (RandomAccessIterator beg, RandomAccessIterator end,BinaryPredicate op)

 

//处理已经排序的算法

//二分查找法，如果是随机访问迭代器则是对数复杂度，否则是线性

bool binary_search (ForwardIterator beg, ForwardIterator end, const T& value)

bool binary_search (ForwardIterator beg, ForwardIterator end, const T& value,BinaryPredicate op)//op为排序规则

 

//判断两个已排序区间2是不是区间1的子集

bool includes (InputIterator1 beg, InputIterator1 end,InputIterator2 searchBeg, InputIterator2 searchEnd)

bool includes (InputIterator1 beg, InputIterator1 end,InputIterator2 searchBeg, InputIterator2 searchEnd,BinaryPredicate op)

 

//小于等于value的第一个元素

ForwardIterator lower_bound (ForwardIterator beg, ForwardIterator end, const T& value)

ForwardIterator lower_bound (ForwardIterator beg, ForwardIterator end, const T& value,BinaryPredicate op)

//大于value的第一个元素

ForwardIterator upper_bound (ForwardIterator beg, ForwardIterator end, const T& value)

ForwardIterator upper_bound (ForwardIterator beg, ForwardIterator end, const T& value,BinaryPredicate op)

 

//查找等于value的区间，如果是随机访问迭代器是对数复杂度，否则是线性复杂度

pair<ForwardIterator,ForwardIterator>equal_range (ForwardIterator beg, ForwardIterator end, const T& value)

pair<ForwardIterator,ForwardIterator>equal_range (ForwardIterator beg, ForwardIterator end, const T& value,BinaryPredicate op)

//合并两个已排序区间

OutputIterator merge (InputIterator source1Beg, InputIterator source1End,

InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg)

OutputIterator merge (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg, BinaryPredicate op)

//合并两个已排序区间，如果一个元素在两个区间内同时出现，则在结果中只会有一份，如果两个源区间中的元素本身就有多个，则目标区间中该元素的个数与两个区间中个数多个保持一致。

OutputIterator set_union (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg)

OutputIterator set_union (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg, BinaryPredicate op)

 

//求两个已排序区间的交集，如果两个区间内同一个元素出现多次，则在目标区间中则也会出现该元素多次

OutputIterator set_intersection (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg)

OutputIterator set_intersection (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg, BinaryPredicate op)

//求两个区间中元素的差集，如果一个元素在两个区间中都出现，且出现次数不同，则结果中该元素的个数等于第一个区间中的个数减去第二个区间中的个数，如果第二个区间中出现的次数更多，则结果中将不会出现该元素

OutputIterator set_difference (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg)

OutputIterator set_difference (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg, BinaryPredicate op)

 

//求在两个区间中只在第一个区间但不在第二个区间或者只在第二个区间不在第一个区间中的元素，如果一个元素在两个区间中出现多次，目标区间中该元素的个数等于，该元素在两个区间中多的减去少的个数

OutputIterator set_symmetric_difference (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg)

OutputIterator set_symmetric_difference (InputIterator source1Beg, InputIterator source1End,InputIterator source2Beg, InputIterator source2End,OutputIterator destBeg, BinaryPredicate op)

 

//在某一个位置合并两个区间

void inplace_merge (BidirectionalIterator beg1, BidirectionalIterator end1beg2,BidirectionalIterator end2)

void inplace_merge (BidirectionalIterator beg1, BidirectionalIterator end1beg2,BidirectionalIterator end2, BinaryPredicate op)

例：

vector<int>v4(20);
iota(v4.begin(), v4.begin() + 10, 0);
iota(v4.begin() + 10,v4.end(), 0);
inplace_merge(v4.begin(), v4.begin() + 10, v4.end());
copy(v4.begin(), v4.end(), ostream_iterator<int>(cout, " "));
//结果：0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

//求和，在initValue的基础上累加

T accumulate (InputIterator beg, InputIterator end,T initValue)

T accumulate (InputIterator beg, InputIterator end,T initValue, BinaryFunc op)

 

//两个区间内各个元素相乘并累加到initValue中

T inner_product (InputIterator1 beg1, InputIterator1 end1,InputIterator2 beg2, T initValue)

T inner_product (InputIterator1 beg1, InputIterator1 end1,InputIterator2 beg2, T initValue,BinaryFunc op1, BinaryFunc op2)

//相对值转换为绝对值

OutputIterator partial_sum (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg)

OutputIterator partial_sum (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg, BinaryFunc op)

• Thus, for the values

a1 a2 a3 ...

they compute either

a1, a1 + a2, a1 + a2 + a3, ...

or

a1, a1 op a2, a1 op a2 op a3, ...

 

//绝对值转换为相对值

OutputIterator adjacent_difference (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg)

OutputIterator adjacent_difference (InputIterator sourceBeg, InputIterator sourceEnd,OutputIterator destBeg, BinaryFunc op)

• Thus, for the values

a1 a2 a3 a4 ...

they compute and write either the values

a1, a2 - a1, a3 - a2, a4 - a3, ...

or the values

a1, a2 op a1, a3 op a2, a4 op a3, ...

张小染
关注
专栏目录
STL中常用的算法
蓬莱道人的博客
03-05 1080
为了处理容器内的元素，STL提供了一些标准算法，包括查找、排序、拷贝、重新排序、修改、数值运算等基本而普遍的算法。算法并非容器内的成员函数，而是一种搭配迭代器使用的全局函数。这么做有一个重要的优势，所有算法只需要实现一份，就可以对所有容器运作，不必为每一种容器量身定做。 1、非更易型算法 2、更易型算法 3、移除型算法 4、变序型算法 5、排序算法 6、已排序区间算法 7、数...
STL算法描述
MyStudy
05-05 959
STL算法部分主要由头文件,,组成。要使用STL中的算法函数必须包含头文件，对于数值算法须包含，中则定义了一些模板类，用来声明函数对象。    STL中算法大致分为四类：        1、非可变序列算法：指不直接修改其所操作的容器内容的算法。        2、可变序列算法：指可以修改它们所操作的容器内容的算法。        3、排序算法：包
STL所有常用算法（全网最详细，一文全掌握，建议收藏）
lyx的博客
08-27 1952
涵盖了C++中STL自带的所有常用算法的定义和使用,包括遍历、查找、排序、拷贝、替换、算术生成和集合算法等, 一文即可全部掌握。
STL中常用算法总结
Dramer
11-24 382
  STL算法众多，很难一一概括，对于我们日常软件开发而言，其实也不需要全部掌握，我们只需要掌握其中最常用的算法并能熟练使用即可。 查找算法 count：利用等于操作符，把标志范围内的元素与输入值比较，返回相等元素个数； count_if：利用输入操作赋，对标志范围内的元素进行操作，返回结果为true的个数； equal_range：功能类似equal，返回一对iterator，第一个表示lower_bound，第二个表示upper_bound; find：利用底层元素的等于操作赋，对指定范围内的元素与输
STL常用算法总结
happydou123的博客
04-08 362
C++标准函数库中，为我们提供了一个algorithm库，里面包含了十分多的常用算法，下面做一个总结 //1.概览: // A:beg和end是表示元素范围的迭代器。 // B:beg2是表示第二个输入序列开始位置的迭代器。end2表示第二个序列的末尾位置，若没有end2，则假定beg2表示的序列至少与beg和end表示的序列一样大。 // C:dest是表示目的序列的迭代器，对于给定输入序...
stl 中常用的算法
weixin_41874599的博客
06-17 333
#include <iostream> #include <vector> #include <algorithm> #include <set> using namespace std; //stl -常用算法 //1.常用遍历算法 //1.1for_each 遍历容器 //1.2transform 搬运容器到另一个容器中 //for_...
c++模板stl常用算法
09-01
本文将详细介绍C++中的模板以及如何利用模板来编写STL中常见的算法。 #### 函数模板(Function Template) 函数模板是一种通用的函数，它能够处理不同的数据类型。使用函数模板可以避免为每种数据类型都编写同样的...
常用的STL查找算法
09-03
在STL中，查找算法是非常常见且实用的功能，用于在序列容器（如数组、向量、列表等）中定位特定元素或满足特定条件的元素。本篇文章将详细介绍几种常用的STL查找算法。 首先，我们要了解查找的基本类别：点、线、面...
C++常用stl算法.pdf
11-22
C++中的STL（Standard Template Library，标准模板库）提供了丰富的算法，可以帮助程序员高效地处理数据。这篇文档主要讨论了C++ STL中的一些常用算法，包括函数对象适配器，如`for_each`、`bind`等。让我们深入探讨...
STL源码剖析与算法详解
最新发布
09-14
内容概要：本PDF书籍深入分析了STL（标准模板库）的各项特性和源码实现，涵盖了类型技术、内存管理、常见算法与数据结构等内容，具体讲解了一系列高级实现技术如STL各种容器（如向量、列表、树、队列等）、RB树结构...
【STL切片算法文献笔记】一种使用 STL 文件进行高效轮廓构造的改进切片算法
atphui的博客
04-22 4121
文章目录一、前言二、研究导览三、方案概述四.切片过程4.1 数据结构4.2 全局切片算法4.3 前向边和后向边判断（FBEJ-算法）4.4 高效的轮廓构造（ECC算法）五. 分析、实施和测试结果 一、前言 STL 模型是通过将实体模型曲面细分为三角形而获得的。 镶嵌的精度由弦误差控制，弦误差是镶嵌模型与原始实体模型之间的最大形状差异。 细分实体模型所需的三角形数量是可接受的弦误差和零件几何复杂性的函数。 在 STL 文件创建过程中生成的大量三角形可能会影响对模型进行切片以及随后为每个切片创建轮廓所需的时间
STL中的算法
m0_37357063的博客
08-18 346
目录 1.STL算法库 2.非修改式序列算法 3.修改式序列算法 4.排序和相关算法 5.通用数值算法   0。参观一下STL有些什么算法： &lt;algorithm&gt; adjacent_find all_of any_of binary_search copy copy_backward copy_if copy_n count count_if e...
STL中一些常用算法
weixin_42573595的博客
09-25 305
函数对象 函数对象概念： 重载函数调用操作符的类，其对象称为函数对象 函数对象使用重载的()时，行为类似函数调用，也叫仿函数 本质：函数对象（仿函数）是一个类，不是一个函数 函数对象使用 特点：函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值 函数对象超出普通函数的概念，函数对象可以有自己的状态 函数对象可以作为参数传递 谓词 概念：返回bool类型的仿函数称为谓词 如果operator()接受一个参数...
STL中的常用算法
flyingleo1981的专栏
09-11 1226
一、非变异算法 是一组不破坏操作数据的模板函数，用来对序列数据进行逐个处理、元素查找、子序列搜索、统计和匹配。非变异算法具有极为广泛的适用性，基本上可应用与各种容器。 1查找容器元素find 它用于查找等于某值的元素。它在迭代器区间[first,last)(闭开区间)上查找等于value值的元素，如果迭代器i所指的元素满足*i=value，则返回迭代器i；未找到满足条件的元素，返回last。
STL常用的算法概述
log_Li的博客
07-11 213
算法概述算法概述常用遍历算法for_each练习代码：transform练习代码：常用查找算法find算法案例常用排序算法常用拷贝和替换算法常用算数生成算法常用集合算法 算法概述 算法主要是由头文件< algorithm > < functional > < numeric >组成。 < algorithm>是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等… < numeric>体积很小，只
C++——STL所有算法介绍
热门推荐
shineHoo的专栏
07-15 2万+
STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件，对于数值算法须包含，中则定义了一些模板类，用来声明函数对象。 STL中算法大致分为四类： 1、非可变序列算法：指不直接修改其所操作的容器内容的算法。 2、可变序列算法：指可以修改它们所操作的容器内容的算法。 3、排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。 4、数值算法：对容器内容进行数值计算。
STL算法概述
Keep Moving~
07-01 702
本文从整体角度介绍了STL所包含的算法，并对算法进行分类，给出每个算法最合算的类别。
C++ STL 中的常见算法详解
这个资源主要涵盖了STL中的一些常见算法，包括查找、计数、生成以及比较等操作。" STL算法在C++编程中扮演着至关重要的角色，它们提供了一种标准方法来处理容器中的元素，如数组、向量、列表等。以下是这些算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值