精华内容
下载资源
问答
  • STL算法

    2020-12-27 15:13:11
    【算法库简介】 #include<algorithm>...STL算法一般采用覆盖,而非插入,调用时应当保证目标空间拥有足够的元素空间。 STL算法允许使用容器自带的算法操作,这些算法更适合容器自身,效率更高。 STL中.

    【算法库简介】   #include<algorithm>

    用有限的步骤解决逻辑或数学上的问题,称为算法。具体的算法是指对解题方案准确而完整的描述,是一系列解决问题的清晰地指令。算法一般分为基本算法、数据结构的算法、数论与代数算法、计算几何算法、图论算法、动态规划及数值分析、加密算法、排序算法、检索算法、随机化算法、并行算法等。

    STL算法一般采用覆盖,而非插入,调用时应当保证目标空间拥有足够的元素空间。

    STL算法允许使用容器自带的算法操作,这些算法更适合容器自身,效率更高。

    STL中的算法大体分为4种:

    【非修改式序列算法】不改动容器中元素的次序、值;

    【修改序列式算法】

    【排序和相关算法】

    【通用数字算法】

     

    展开全文
  • STL 算法

    千次阅读 2016-06-03 19:24:08
    STL算法概述 查找算法 堆算法 关系算法 集合算法 排列组合算法 排序和通用算法 删除和替换算法 生成和变异算法 算数算法 STL算法概述 简介: STL算法部分主要由头文件,,组成。要使用 STL中的算法函
    

    阅读程序的时候有一个地方不太懂,竟然让我发现了这个总结,感觉很有用!!!

    STL算法


    目录

    STL算法概述
    查找算法
    堆算法
    关系算法
    集合算法
    排列组合算法
    排序和通用算法
    删除和替换算法
    生成和变异算法
    算数算法


    STL算法概述

    简介:

    STL算法部分主要由头文件<algorithm>,<numeric>,<functional>组成。要使用 STL中的算法函数必须包含头文件<algorithm>,对于数值算法须包含<numeric><functional>中则定义了一些模板类,用来声明函数对象

    注意:

    编译器无法检测出所传递的迭代器是一个无效形式的迭代器,当然也无法给出算法函数错误的提示,因为迭代器并不是真实的类别,它只是传递给函数模板的一种参数格式而已

    STL中算法分类:

    • 操作对象

      • 直接改变容器的内容

      • 将原容器的内容复制一份,修改其副本,然后传回该副本

    • 功能:

      • 非可变序列算法指不直接修改其所操作的容器内容的算法

      • 可变序列算法指可以修改它们所操作的容器内容的算法

      • 排序算法包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作

      • 数值算法对容器内容进行数值计算


        查找算法(13):判断容器中是否包含某个值

    函数名

    头文件

    函数功能

    adjacent_find

    <algorithm>

    iterator对标识元素范围内,查找一对相邻重复元素,找到则返回指向这对元素的第一个元素的ForwardIterator .否则返回last.重载版本使用输入的二元操作符代替相等的判断

    函数原形

    template<class FwdIt> FwdIt adjacent_find(FwdIt first, FwdIt last);

    template<class FwdIt, class Pred> FwdIt adjacent_find(FwdIt first, FwdIt last, Pred pr);

    binary_search

    <algorithm>

    在有序序列中查找value,找到返回true.重载的版本实用指定的比较函数对象或函数指针来判断相等

    函数原形

    template<class FwdIt, class T> bool binary_search(FwdIt first, FwdIt last, const T& val);

    template<class FwdIt, class T, class Pred> bool binary_search(FwdIt first, FwdIt last, const T& val,Pred pr);

    count

    <algorithm>

    利用等于操作符,把标志范围内的元素与输入值比较,返回相等元素个数

    函数原形

    template<class InIt, class Dist> size_t count(InIt first, InIt last,const T& val, Dist& n);

    count_if

    <algorithm>

    利用输入的操作符,对标志范围内的元素进行操作,返回结果为true的个数

    函数原形

    template<class InIt, class Pred, class Dist> size_t count_if(InIt first, InIt last, Pred pr);

    equal_range

    <algorithm>

    功能类似equal,返回一对iterator,第一个表示lower_bound,第二个表示upper_bound

    函数原形

    template<class FwdIt, class T> pair<FwdIt, FwdIt> equal_range(FwdIt first, FwdIt last,const T& val);

    template<class FwdIt, class T, class Pred> pair<FwdIt, FwdIt> equal_range(FwdIt first, FwdIt last,const T& val, Pred pr);

    find

    <algorithm>

    利用底层元素的等于操作符,对指定范围内的元素与输入值进行比较.当匹配时,结束搜索,返回该元素的一个InputIterator

    函数原形

    template<class InIt, class T> InIt find(InIt first, InIt last, const T& val);

    find_end

    <algorithm>

    在指定范围内查找"由输入的另外一对iterator标志的第二个序列"的最后一次出现.找到则返回最后一对的第一个ForwardIterator,否则返回输入的"另外一对"的第一个ForwardIterator.重载版本使用用户输入的操作符代替等于操作

    函数原形

    template<class FwdIt1, class FwdIt2> FwdIt1 find_end(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2);

    template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 find_end(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2, Pred pr);

    find_first_of

    <algorithm>

    在指定范围内查找"由输入的另外一对iterator标志的第二个序列"中任意一个元素的第一次出现。重载版本中使用了用户自定义操作符

    函数原形

    template<class FwdIt1, class FwdIt2> FwdIt1 find_first_of(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2);

    template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 find_first_of(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2, Pred pr);

    find_if

    <algorithm>

    使用输入的函数代替等于操作符执行find

     

    template<class InIt, class Pred> InIt find_if(InIt first, InIt last, Pred pr);

    lower_bound

    <algorithm>

    返回一个ForwardIterator,指向在有序序列范围内的可以插入指定值而不破坏容器顺序的第一个位置.重载函数使用自定义比较操作

    函数原形

    template<class FwdIt, class T> FwdIt lower_bound(FwdIt first, FwdIt last, const T& val);

    template<class FwdIt, class T, class Pred> FwdIt lower_bound(FwdIt first, FwdIt last, const T& val, Pred pr);

    upper_bound

    <algorithm>

    返回一个ForwardIterator,指向在有序序列范围内插入value而不破坏容器顺序的最后一个位置,该位置标志一个大于value的值.重载函数使用自定义比较操作

    函数原形

    template<class FwdIt, class T> FwdIt upper_bound(FwdIt first, FwdIt last, const T& val);

    template<class FwdIt, class T, class Pred> FwdIt upper_bound(FwdIt first, FwdIt last, const T& val, Pred pr);

    search

    <algorithm>

    给出两个范围,返回一个ForwardIterator,查找成功指向第一个范围内第一次出现子序列(第二个范围)的位置,查找失败指向last1,重载版本使用自定义的比较操作

    函数原形

    template<class FwdIt1, class FwdIt2> FwdIt1 search(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2);

    template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 search(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2, Pred pr);

    search_n

    <algorithm>

    在指定范围内查找val出现n次的子序列。重载版本使用自定义的比较操作

    函数原形

    template<class FwdIt, class Dist, class T> FwdIt search_n(FwdIt first, FwdIt last,Dist n, const T& val);

    template<class FwdIt, class Dist, class T, class Pred> FwdIt search_n(FwdIt first, FwdIt last,Dist n, const T& val, Pred pr);


    堆算法(4)

    函数名

    头文件

    函数功能

    make_heap

    <algorithm>

    把指定范围内的元素生成一个堆。重载版本使用自定义比较操作

    函数原形

    template<class RanIt> void make_heap(RanIt first, RanIt last);

    template<class RanIt, class Pred> void make_heap(RanIt first, RanIt last, Pred pr);

    pop_heap

    <algorithm>

    并不真正把最大元素从堆中弹出,而是重新排序堆。它把firstlast-1交换,然后重新生成一个堆。可使用容器的back来访问被"弹出"的元素或者使用pop_back进行真正的删除。重载版本使用自定义的比较操作

    函数原形

    template<class RanIt> void pop_heap(RanIt first, RanIt last);

    template<class RanIt, class Pred> void pop_heap(RanIt first, RanIt last, Pred pr);

    push_heap

    <algorithm>

    假设firstlast-1是一个有效堆,要被加入到堆的元素存放在位置last-1,重新生成堆。在指向该函数前,必须先把元素插入容器后。重载版本使用指定的比较操作

    函数原形

    template<class RanIt>void push_heap(RanIt first, RanIt last);

    template<class RanIt, class Pred> void push_heap(RanIt first, RanIt last, Pred pr);

    sort_heap

    <algorithm>

    对指定范围内的序列重新排序,它假设该序列是个有序堆。重载版本使用自定义比较操作

    函数原形

    template<class RanIt> void sort_heap(RanIt first, RanIt last);

    template<class RanIt, class Pred> void sort_heap(RanIt first, RanIt last, Pred pr);


    关系算法(8)

    函数名

    头文件

    函数功能

    equal

    <algorithm>

    如果两个序列在标志范围内元素都相等,返回true。重载版本使用输入的操作符代替默认的等于操作符

    函数原形

    template<class InIt1, class InIt2> bool equal(InIt1 first, InIt1 last, InIt2 x);

    template<class InIt1, class InIt2, class Pred> bool equal(InIt1 first, InIt1 last, InIt2 x, Pred pr);

    includes

    <algorithm>

    判断第一个指定范围内的所有元素是否都被第二个范围包含,使用底层元素的<操作符,成功返回true。重载版本使用用户输入的函数

    函数原形

    template<class InIt1, class InIt2> bool includes(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2);

    template<class InIt1, class InIt2, class Pred> bool includes(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, Pred pr);

    lexicographical_compare

    <algorithm>

    比较两个序列。重载版本使用用户自定义比较操作

    函数原形

    template<class InIt1, class InIt2> bool lexicographical_compare(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2);

    template<class InIt1, class InIt2, class Pred> bool lexicographical_compare(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, Pred pr);

    max

    <algorithm>

    返回两个元素中较大一个。重载版本使用自定义比较操作

    函数原形

    template<class T> const T& max(const T& x, const T& y);

    template<class T, class Pred> const T& max(const T&  x, const T& y, Pred pr);

    max_element

    <algorithm>

    返回一个ForwardIterator,指出序列中最大的元素。重载版本使用自定义比较操作

    函数原形

    template<class FwdIt> FwdIt max_element(FwdIt first, FwdIt last);

    template<class FwdIt, class Pred> FwdIt max_element(FwdIt first, FwdIt last, Pred pr);

    min

    <algorithm>

    返回两个元素中较小一个。重载版本使用自定义比较操作

    函数原形

    template<class T> const T& min(const T& x, const T& y);

    template<class T, class Pred> const T& min(const T& x, const T& y, Pred pr);

    min_element

    <algorithm>

    返回一个ForwardIterator,指出序列中最小的元素。重载版本使用自定义比较操作

    函数原形

    template<class FwdIt> FwdIt min_element(FwdIt first, FwdIt last);

    template<class FwdIt, class Pred> FwdIt min_element(FwdIt first, FwdIt last, Pred pr);

    mismatch

    <algorithm>

    并行比较两个序列,指出第一个不匹配的位置,返回一对iterator,标志第一个不匹配元素位置。如果都匹配,返回每个容器的last。重载版本使用自定义的比较操作

    函数原形

    template<class InIt1, class InIt2> pair<InIt1, InIt2> mismatch(InIt1 first, InIt1 last, InIt2 x);

    template<class InIt1, class InIt2, class Pred> pair<InIt1, InIt2> mismatch(InIt1 first, InIt1 last, InIt2 x, Pred pr);


    集合算法(4)

    函数名

    头文件

    函数功能

    set_union

    <algorithm>

    构造一个有序序列,包含两个序列中所有的不重复元素。重载版本使用自定义的比较操作

    函数原形

    template<class InIt1, class InIt2, class OutIt> OutIt set_union(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x);

    template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_union(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2,OutIt x, Pred pr);

    set_intersection

    <algorithm>

    构造一个有序序列,其中元素在两个序列中都存在。重载版本使用自定义的比较操作

    函数原形

    template<class InIt1, class InIt2, class OutIt> OutIt set_intersection(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x);

    template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_intersection(InIt1 first1, InIt1 last1,InIt2 first2,InIt2 last2, OutIt x, Pred pr);

    set_difference

    <algorithm>

    构造一个有序序列,该序列仅保留第一个序列中存在的而第二个中不存在的元素。重载版本使用自定义的比较操作

    函数原形

    template<class InIt1, class InIt2, class OutIt> OutIt set_difference(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x);

    template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x, Pred pr);

    set_symmetric_difference

    <algorithm>

    构造一个有序序列,该序列取两个序列的对称差集(并集-交集)

    函数原形

    template<class InIt1, class InIt2, class OutIt> OutIt set_symmetric_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x);

    template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_symmetric_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x, Pred pr);


    排列组合算法(2)提供计算给定集合按一定顺序的所有可能排列组合

    函数名

    头文件

    函数功能

    next_permutation

    <algorithm>

    取出当前范围内的排列,并重新排序为下一个排列。重载版本使用自定义的比较操作

    函数原形

    template<class BidIt> bool next_permutation(BidIt first, BidIt last);

    template<class BidIt, class Pred> bool next_permutation(BidIt first, BidIt last, Pred pr);

    prev_permutation

    <algorithm>

     取出指定范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回false。重载版本使用自定义的比较操作

    函数原形

    template<class BidIt> bool prev_permutation(BidIt first, BidIt last);

    template<class BidIt, class Pred> bool prev_permutation(BidIt first, BidIt last, Pred pr);


    排序和通用算法(14):提供元素排序策略

    函数名

    头文件

    函数功能

    inplace_merge

    <algorithm>

    合并两个有序序列,结果序列覆盖两端范围。重载版本使用输入的操作进行排序

    函数原形

    template<class BidIt> void inplace_merge(BidIt first, BidIt middle, BidIt last);

    template<class BidIt, class Pred> void inplace_merge(BidIt first, BidIt middle, BidIt last, Pred pr);

    merge

    <algorithm>

    合并两个有序序列,存放到另一个序列。重载版本使用自定义的比较

    函数原形

    template<class InIt1, class InIt2, class OutIt> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x);

    template<class InIt1, class InIt2, class OutIt, class Pred> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x, Pred pr);

    nth_element

    <algorithm>

    将范围内的序列重新排序,使所有小于第n个元素的元素都出现在它前面,而大于它的都出现在后面。重载版本使用自定义的比较操作

    函数原形

    template<class RanIt> void nth_element(RanIt first, RanIt nth, RanIt last);

    template<class RanIt, class Pred> void nth_element(RanIt first, RanIt nth, RanIt last, Pred pr);

    partial_sort

    <algorithm>

    对序列做部分排序,被排序元素个数正好可以被放到范围内。重载版本使用自定义的比较操作

    函数原形

    template<class RanIt> void partial_sort(RanIt first, RanIt middle, RanIt last);

    template<class RanIt, class Pred> void partial_sort(RanIt first, RanIt middle, RanIt last, Pred pr);

    partial_sort_copy

    <algorithm>

    partial_sort类似,不过将经过排序的序列复制到另一个容器

    函数原形

    template<class InIt, class RanIt> RanIt partial_sort_copy(InIt first1, InIt last1,RanIt first2, RanIt last2);

    template<class InIt, class RanIt, class Pred> RanIt partial_sort_copy(InIt first1, InIt last1,RanIt first2, RanIt last2, Pred pr);

    partition

    <algorithm>

    对指定范围内元素重新排序,使用输入的函数,把结果为true的元素放在结果为false的元素之前

    函数原形

    template<class BidIt, class Pred> BidIt partition(BidIt first, BidIt last, Pred pr);

    random_shuffle

    <algorithm>

    对指定范围内的元素随机调整次序。重载版本输入一个随机数产生操作

    函数原形

    template<class RanIt> void random_shuffle(RanIt first, RanIt last);

    template<class RanIt, class Fun> void random_shuffle(RanIt first, RanIt last, Fun& f);

    reverse

    <algorithm>

    将指定范围内元素重新反序排序

    函数原形

    template<class BidIt> void reverse(BidIt first, BidIt last);

    reverse_copy

    <algorithm>

    reverse类似,不过将结果写入另一个容器

    函数原形

    template<class BidIt, class OutIt> OutIt reverse_copy(BidIt first, BidIt last, OutIt x);

    rotate

    <algorithm>

    将指定范围内元素移到容器末尾,由middle指向的元素成为容器第一个元素

    函数原形

    template<class FwdIt> void rotate(FwdIt first, FwdIt middle, FwdIt last);

    rotate_copy

    <algorithm>

    rotate类似,不过将结果写入另一个容器

    函数原形

    template<class FwdIt, class OutIt> OutIt rotate_copy(FwdIt first, FwdIt middle, FwdIt last, OutIt x);

    sort

    <algorithm>

    以升序重新排列指定范围内的元素。重载版本使用自定义的比较操作

    函数原形

    template<class RanIt> void sort(RanIt first, RanIt last);

    template<class RanIt, class Pred> void sort(RanIt first, RanIt last, Pred pr);

    stable_sort

    <algorithm>

    sort类似,不过保留相等元素之间的顺序关系

    函数原形

    template<class BidIt> void stable_sort(BidIt first, BidIt last);

    template<class BidIt, class Pred> void stable_sort(BidIt first, BidIt last, Pred pr);

    stable_partition

    <algorithm>

    partition类似,不过不保证保留容器中的相对顺序

    函数原形

    template<class FwdIt, class Pred> FwdIt stable_partition(FwdIt first, FwdIt last, Pred pr);


    删除和替换算法(15)

    函数名

    头文件

    函数功能

    copy

    <algorithm>

    复制序列

    函数原形

    template<class InIt, class OutIt> OutIt copy(InIt first, InIt last, OutIt x);

    copy_backward

    <algorithm>

    copy相同,不过元素是以相反顺序被拷贝

    函数原形

    template<class BidIt1, class BidIt2> BidIt2 copy_backward(BidIt1 first, BidIt1 last, BidIt2 x);

    iter_swap

    <algorithm>

    交换两个ForwardIterator的值

    函数原形

    template<class FwdIt1, class FwdIt2> void iter_swap(FwdIt1 x, FwdIt2 y);

    remove

    <algorithm>

    删除指定范围内所有等于指定元素的元素。注意,该函数不是真正删除函数。内置函数不适合使用removeremove_if函数

    函数原形

    template<class FwdIt, class T> FwdIt remove(FwdIt first, FwdIt last, const T& val);

    remove_copy

    <algorithm>

    将所有不匹配元素复制到一个制定容器,返回OutputIterator指向被拷贝的末元素的下一个位置

    函数原形

    template<class InIt, class OutIt, class T> OutIt remove_copy(InIt first, InIt last, OutIt x, const T& val);

    remove_if

    <algorithm>

    删除指定范围内输入操作结果为true的所有元素

    函数原形

    template<class FwdIt, class Pred> FwdIt remove_if(FwdIt first, FwdIt last, Pred pr);

    remove_copy_if

    <algorithm>

    将所有不匹配元素拷贝到一个指定容器

    函数原形

    template<class InIt, class OutIt, class Pred> OutIt remove_copy_if(InIt first, InIt last, OutIt x, Pred pr);

    replace

    <algorithm>

    将指定范围内所有等于vold的元素都用vnew代替

    函数原形

    template<class FwdIt, class T> void replace(FwdIt first, FwdIt last,const T& vold, const T& vnew);

    replace_copy

    <algorithm>

    replace类似,不过将结果写入另一个容器

    函数原形

    template<class InIt, class OutIt, class T> OutIt replace_copy(InIt first, InIt last, OutIt x,const T& vold, const T& vnew);

    replace_if

    <algorithm>

    将指定范围内所有操作结果为true的元素用新值代替

    函数原形

    template<class FwdIt, class Pred, class T> void replace_if(FwdIt first, FwdIt last,Pred pr, const T& val);

    replace_copy_if

    <algorithm>

    replace_if,不过将结果写入另一个容器

    函数原形

    template<class InIt, class OutIt, class Pred, class T> OutIt replace_copy_if(InIt first, InIt last, OutIt x, Pred pr, const T& val);

    swap

    <algorithm>

    交换存储在两个对象中的值

    函数原形

    template<class T> void swap(T& x, T& y);

    swap_range

    <algorithm>

    将指定范围内的元素与另一个序列元素值进行交换

    函数原形

    template<class FwdIt1, class FwdIt2> FwdIt2 swap_ranges(FwdIt1 first, FwdIt1 last, FwdIt2 x);

    unique

    <algorithm>

    清除序列中重复元素,和remove类似,它也不能真正删除元素。重载版本使用自定义比较操作

    函数原形

    template<class FwdIt> FwdIt unique(FwdIt first, FwdIt last);

    template<class FwdIt, class Pred> FwdIt unique(FwdIt first, FwdIt last, Pred pr);

    unique_copy

    <algorithm>

    unique类似,不过把结果输出到另一个容器

    函数原形

    template<class InIt, class OutIt> OutIt unique_copy(InIt first, InIt last, OutIt x);

    template<class InIt, class OutIt, class Pred> OutIt unique_copy(InIt first, InIt last, OutIt x, Pred pr);


    生成和变异算法(6)

    函数名

    头文件

    函数功能

    fill

    <algorithm>

    将输入值赋给标志范围内的所有元素

    函数原形

    template<class FwdIt, class T> void fill(FwdIt first, FwdIt last, const T& x);

    fill_n

    <algorithm>

    将输入值赋给firstfirst+n范围内的所有元素

    函数原形

    template<class OutIt, class Size, class T> void fill_n(OutIt first, Size n, const T& x);

    for_each

    <algorithm>

    用指定函数依次对指定范围内所有元素进行迭代访问,返回所指定的函数类型。该函数不得修改序列中的元素

    函数原形

    template<class InIt, class Fun> Fun for_each(InIt first, InIt last, Fun f);

    generate

    <algorithm>

    连续调用输入的函数来填充指定的范围

    函数原形

    template<class FwdIt, class Gen> void generate(FwdIt first, FwdIt last, Gen g);

    generate_n

    <algorithm>

    generate函数类似,填充从指定iterator开始的n个元素

    函数原形

    template<class OutIt, class Pred, class Gen> void generate_n(OutIt first, Dist n, Gen g);

    transform

    <algorithm>

    将输入的操作作用与指定范围内的每个元素,并产生一个新的序列。重载版本将操作作用在一对元素上,另外一个元素来自输入的另外一个序列。结果输出到指定容器

    函数原形

    template<class InIt, class OutIt, class Unop> OutIt transform(InIt first, InIt last, OutIt x, Unop uop);

    template<class InIt1, class InIt2, class OutIt, class Binop> OutIt transform(InIt1 first1, InIt1 last1, InIt2 first2,OutIt x, Binop bop);


    算数算法(4)

    函数名

    头文件

    函数功能

    accumulate

    <numeric>

    iterator对标识的序列段元素之和,加到一个由val指定的初始值上。重载版本不再做加法,而是传进来的二元操作符被应用到元素上

    函数原形

    template<class InIt, class T> T accumulate(InIt first, InIt last, T val);

    template<class InIt, class T, class Pred> T accumulate(InIt first, InIt last, T val, Pred pr);

    partial_sum

    <numeric>

    创建一个新序列,其中每个元素值代表指定范围内该位置前所有元素之和。重载版本使用自定义操作代替加法

    函数原形

    template<class InIt, class OutIt> OutIt partial_sum(InIt first, InIt last,OutIt result);

    template<class InIt, class OutIt, class Pred> OutIt partial_sum(InIt first, InIt last,OutIt result, Pred pr);

    product

    <numeric>

    对两个序列做内积(对应元素相乘,再求和)并将内积加到一个输入的初始值上。重载版本使用用户定义的操作

    函数原形

    template<class InIt1, class InIt2, class T> T product(InIt1 first1, InIt1 last1,Init2 first2, T val);

    template<class InIt1, class InIt2, class T,class Pred1, class Pred2> T product(InIt1 first1, InIt1 last1,Init2 first2, T val, Pred1 pr1, Pred2 pr2);

    adjacent_difference

    <numeric>

    创建一个新序列,新序列中每个新值代表当前元素与上一个元素的差。重载版本用指定二元操作计算相邻元素的差

    函数原形

    template<class InIt, class OutIt> OutIt adjacent_difference(InIt first, InIt last,OutIt result);

    template<class InIt, class OutIt, class Pred> OutIt adjacent_difference(InIt first, InIt last,OutIt result, Pred pr);

     

    
    展开全文
  • 1.STL算法的简介 2.STL常见的算法 3.STL算法应用举例 昆山爱达人信息技术有限公司 QQ:254830010 本节内容 STL算法简介 STL提供了能在各种容器中通用的算法比如插入删除查找排序等 算法部分主要由头文件和组成 是所有...
  • stl算法中文解析.rar

    2021-04-05 23:33:54
    stl算法中文解析
  • STL算法整理

    2013-10-25 17:17:42
    STL算法整理 T C C++ STL Linux Windo
  • STL算法分类

    2012-10-04 19:17:10
    STL算法分类
  • c++非变易算法-stl算法

    2020-12-31 15:23:59
    STL的三大组成部分为容器、迭代器、算法,本文主要讲解STL算法中的非变易算法。本文从实践的角度简单介绍了一下相关函数的使用。C++ STL的非变易算法(Non-mutating algorithms)是一组不破坏函数数据的模板函数,...
  • STL算法的简介

    2020-10-31 08:59:08
    一、STL算法介绍 STL算法部分主要是由三个头文件承担: algorithm、numeric、functional algorithm:意思是算法,只要想使用STL库中的算法函数就得包含该头文件。 numeric:包含了一系列用于计算数值序列的算法,...

    一、STL算法介绍

    STL算法部分主要是由三个头文件承担: algorithm、numeric、functional

    1. algorithm:意思是算法,只要想使用STL库中的算法函数就得包含该头文件。
    2. numeric:包含了一系列用于计算数值序列的算法,其具有一定的灵活性,也能够适用于部分非数值序列的计算
    3. functional:定义了一些模板,可以用来声明函数对象。

    二、STL算法分类

    质变与非质变算法:

    1. 质变算法:会改变操作对象的值。所有的STL算法都作用在[first,last)所标示的区间上,在运算过程中改变区间元素值。例如:copy,swap,replace,fill,remove,permulation,partition,sort等。
    2. 非质变算法:不改变操作对象之值。例如:find,search,count,equal,max,min等。

    举个例子

    	int test[] = {100,23,45,53,56,90,98,96,95};
    	vector<int> temp(test,test+sizeof(test)/sizeof (int));
    	vector<int>::const_iterator crita1 = temp.begin();
    	vector<int>::const_iterator crita2 = temp.end();
    	sort(crita1, crita2);

    以上sort操作,编译器会报错

    三、STL算法的一般形式

    STL算法的一般形式——泛型算法。所有泛型算法的前两个参数都是一对迭代器,通常称为first,last,以标示算法的操作区间,前闭后开。这个[first,last)区间的必要条件是:必须能够经由increment(累加)操作的反复运用,从first到last。编译器本身无法强求这一点,如果这个条件不成立,会导致未可预期的后果。

    根据行进特性,迭代器分五种:Input Iterator、Output Iterator、Forward Iterator、Bidirectional Iterator、Random Access Iterator。这五种迭代器的逻辑层次见下图。每一个STL算法的声明都表现出它所需要的最低程度的迭代器类型。比如 find() 函数,它需要一个Input Iterator,但你给它传Forward Iterator或Bidirectional Iterator等都可以,就是不能传Output Iterator,否则会导致错误。同样,将无效的迭代器传给某个算法并不能保证在编译的时候能被捕捉,因此一定要小心使用。

    许多STL算法不止支持一个版本。这一类的算法的某个版本采用缺省运算行为,另一个版本提供额外参数,接受外界传入一个仿函数,以便采用其他策略,这种函数一般会用"_if"结尾表示。

    质变算法通常提供两个版本,就地的和复制到他处的,一般复制到他处的会以"_copy"结尾表示。当然并非所有质变算法都有copy版本,如 sort() 就没有。

    所有的数值算法都实现于 <stl_numeric.h> 中,但这是内部文件,规定用户必须包含其上层的 <numeric> 。其他的算法实现于 <stl_algo.h><stl_algobase.h> 中,也都是内部文件,欲使用这些算法须包含上层头文件 <algorithm>

    四、算法的泛化过程

    如设计一个算法,使它适用于任何(大多数)数据结构?

    将算法独立于其所处理的数据结构之外,不受数据结构的羁绊。关键在于:将操作对象的型别抽象化,把操作对象的标识符和区间目标的移动行为抽象化。整个算法也就在一个抽象的层面上了。整个过程称为泛型化(generalized),简称泛化。

    让我们看看算法泛化的一个实例,以简单的循序查找为例。假设我们要写一个find()函数,在array中寻找特定值。面对array,我们的直觉反应是:

    int* find(int *arrayHead,int arraySize,int value)
    {
        int i;
        for(i=0;i<arraySize;i++)
        {    if(arrayHead[i]==value)
            break;
        }
        return &(arrayHead[i]);
    }

    该函数在某一个区间内查找,返回的是一个指针,指向符合标准的第一个元素。

    为例让find()函数适用于所有类型的容器,其操作应当抽象化些,让find()接受两个指针作为参数,标示出一个操作区间,这就是很好的做法:

    int* find(int* begin,int* end,int value)
    {
        while(begin!=end&&*begin!=value)
            ++begin;
        return begin;
    }

     由于find()函数之内并无任何操作是针对特定的整数array而发的,所以我们将它改成一个template:

    template<class T>
    T* find(T* begin,T*end,const T& value)
    {
        while(begin!=end&&*begin!=value)
            ++begin;
        return begin;
    }

    C++有一个极大的优点,几乎所有的东西都可以改为程序员自定义的形式或行为,上述这些操作符和操作行为都可以被重载(overloaded),既是如此,何必将find局限于使用指针呢?从原生指针中的思想框架逃离出来。

    比如我们以一个原生指针指向某个List(链表),则对该指针进行“++”操作并不能使它指向下一个串行节点,但如果我们设计class,拥有原生指针的行为,并使其“++”操作指向list的下一个节点,那么find()就可以施行于List容器身上了。这便是迭代器的观念。迭代器是一种行为类似指针的对象,换句话说,是一种smart pointers。现以迭代器重新写过:

    template<class Iterator,class T>
    Iterator* find(Iterator* begin,Iterator* end,const T& value)
    {
        while(begin!=end&&*begin!=value)
            ++begin;
        return begin;
    }

    这便是一个完全泛化的find()函数,你可以在C++标准库的某一个头文件中看到它,长相几乎一模一样。

     

    参考:

    https://blog.csdn.net/qq_43549984/article/details/99691556

    https://blog.csdn.net/qq_34777600/article/details/80503190

    展开全文
  • STL算法algorithm

    2019-03-17 08:22:23
    STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件,对于数值算法须包含,中则定义了一些模板类,用来声明函数对象。 STL中算法大致分为四类: 非可变序列算法:指不直接修改其所操作的容器...

    STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件,对于数值算法须包含,中则定义了一些模板类,用来声明函数对象。

    STL中算法大致分为四类:

    1. 非可变序列算法:指不直接修改其所操作的容器内容的算法。
    2. 可变序列算法:指可以修改它们所操作的容器内容的算法。
    3. 排序算法:包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。
    4. 数值算法:对容器内容进行数值计算。

    查找算法:

    判断容器中是否包含某个值
    在这里插入图片描述

    排序和通用算法:

    提供元素排序策略
    在这里插入图片描述

    删除和替换算法

    在这里插入图片描述

    算术算法

    在这里插入图片描述

    生成和异变算法

    在这里插入图片描述

    关系算法

    在这里插入图片描述

    堆算法

    在这里插入图片描述

    展开全文
  • STL算法概观

    千次阅读 2017-07-20 15:50:43
    ## STL算法 ##更易型算法 非更易型算法 移除型算法 变序型算法 排序算法 已排序区间算法 数值算法for_each 算法 count 算法 count_if 算法 min_element 算法 max_element 算法 minmax_element 算法(c++11) find 算法...
  • C++ STL算法

    2019-12-22 16:37:51
    ,使用STL算法时,常常用到函数对象和函数适配器,因此需要<functional> 算法概述 两个特殊后缀: 1.后缀_if 2.后缀_copy 按照功能来分类: 1.非更易型算法 2.更易型算法 3.移除型算法 4...
  • STL算法入门ppt

    2014-05-02 21:10:42
    ACM STL算法入门 导入 STL的概念与组成 Iterator(迭代器) Container(容器) Algorithm(算法) Adaptors(配接器)
  • stl算法的知识

    2014-03-04 12:31:49
    STL算法相关的一些知识,可以参阅学习,使用起来很方便
  • STL算法概述

    千次阅读 2014-03-24 00:11:03
    STL算法概述 查找算法 堆算法 关系算法 集合算法 排列组合算法 排序和通用算法 删除和替换算法 生成和变异算法 算数算法 STL算法概述 简介: STL算法部分主要由头文件,,组成。要使用 STL中的算法函数...
  • 09~STL算法

    2020-02-04 14:31:43
    文章目录1....C++ STL算法有两个特点: 算法使用模板提供泛型,其次使用迭代器来提供容器的通用表示 1. 算法分组 常见的算法如下 sort copy find random_shuffle set_union set_intersection set_dif...
  • 学习C++:STL算法

    2020-02-12 00:59:14
    STL算法就是像查找、搜索、删除等操作的通用函数,其应用范围很广。要使用STL算法,应用程序必须包含头文件。
  • cpp的STL算法

    千次阅读 2016-11-01 14:28:47
    cpp的STL算法什么是stl算法操作stl集合的一堆方法。很方便,他们就是一堆工具。你只要熟悉stl就可以很方便的使用他们啦。先明白算法有哪些,有什么作用,然后熟悉一部分常用的,其他的在实践中时候用stl算法的分类非...
  • 【C++21天养成计划】STL算法超全整理!(Day18)

    万次阅读 多人点赞 2020-10-04 22:36:17
    横扫STL算法,帅翻全场!
  • STL算法实现

    2014-09-03 16:26:26
    写了一点STL算法,模板biancheng
  • STL算法总体概览

    2020-02-12 10:27:00
    下面的一些文章我们将探讨极具复用价值的70余个STL算法,包括排序(sorting)、查找(searching)、排列组合(permutation)、以及用于数据移动、赋值、删除、比较、组合、运算等的算法 特定的算法往往搭配特定的...
  • 包含了stl算法的代码,大家可以下载以后用压缩文件自带的应用程序打开,并且用ctrl+c ctrl+v来复制代码,然后再编译器打开,学习stl
  • STL算法(一)

    2020-03-19 18:06:04
    简单总结今天学习的STL算法相关知识: STL算法分类: (1)不可变序列算法 #include<iostream> #include<vector> #include<functional> #include<algorithm> using namespace std; int main...
  • STL算法简介

    千次阅读 2013-08-18 16:08:03
    STL算法概述 简介: STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件,对于数值算法须包含,中则定义了一些模板类,用来声明函数对象 注意: 编译器无法检测出所传递的迭代器是一个无效形式的...
  • STL算法 STL中的算法大致可以分为以下七类: 不变序列算法 变值算法 删除算法 变序算法 排序算法 有序区间算法 数值算法 大多重载的算法都是有两个版本的 用 “==” 判断元素是否相等, 或用 “<” 来比较大小 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,087
精华内容 7,634
关键字:

stl算法