C++标准库（三）之STL算法

  • 算法头文件：

    #include<algorithm>
#include<numeric>
  • 算法简介：STL算法采用覆盖模式而非安插模式，所以调用者必须保证有足够的操作空间。
  • 函数对象类型声明：
    • UnaryProc：Op(elem)，无返回值
    • CompFunc：Op(elem1,elem2)，返回True或者False
    • UnaryPredicate：Op(elem)，返回True或者False
    • BinaryPredicate：Op(elem,value)，返回True或者False

      非更易型算法

  • 元素计数 
    UnaryProc for_each(InputIterator beg,InputIterator end,UnaryProc Op)
difference_type count(InputIterator beg,InputIterator end,const T& val)
difference_type count_if(InputIterator beg,InputIterator end,UnaryProc Op)
  • 最小值与最大值 
    ForwardIterator min_element(ForwardIterator beg,ForwardIterator end)
ForwardIterator min_element(ForwardIterator beg,ForwardIterator end,CompFunc Op)
ForwardIterator max_element(ForwardIterator beg,ForwardIterator end)
ForwardIterator max_element(ForwardIterator beg,ForwardIterator end,CompFunc Op)
pair<ForwardIterator,ForwardIterator> minmax_element(ForwardIterator beg,ForwardIterator end)
pair<ForwardIteraror,ForwardIterator> minmax_element(ForwardIterator beg,ForwardIterator end,CompFunc Op)
  • 查找元素

    ```

    //查找第一个匹配的元素

    InputIterator find(InputIterator beg,InputIterator end,const T& value);

    InputIterator find_if(InputIterator beg,InputIterator end,UnaryPredicate Op);

    InputIterator find_if_not(InputIterator beg,InputIterator end,UnaryPredicate Op);

//查找前n个连续匹配的值

ForwardIterator search_n(ForwardIterator beg,ForwardIterator end,size count,const T& value);

ForwardIterator search_n(ForwardIterator beg,ForwardIterator end,size count,const T& value,BinaryPredicate Op);

//查找第一个子区间

ForwardIterator1 search(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 searchBeg,ForwardIterator2 searchEnd);

ForwardIterator1 search(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 searchBeg,ForwardIterator2 searchEnd,BinaryPredicate Op);

//查找最后一个子区间

ForwardIterator1 find_end(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 searchBeg,ForwardIterator2 searchEnd);

ForwardIterator1 find_end(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 searchBeg,ForwardIterator2 searchEnd,BinaryPredicate Op);

//查找某些元素第一次出现的地点

InputIterator find_first_of(InputIterator beg,InputIterator end,ForwardIterator searchBeg,ForwardIterator searchEnd);

InputIterator find_first_of(InputIterator beg,InputIterator end,ForwardIterator searchBeg,ForwardIterator searchEnd,BinaryPredicate Op);

//查找两个连续且相等的元素

ForwardIterator adjacent_find(ForwardIterator beg,ForwardIterator end);

ForwardIterator adjacent_find(ForwardIterator beg,ForwardIterator end,BinaryPredicate Op);

- 区间的比较

//验证相等性

bool equal(InputIterator1 beg,InputIterator1 end,InputIterator2 cmpBeg)；

bool equal(InputIterator1 beg,InputIterator1,end,InputIterator2 cmpBeg,BinaryPredicate op);

//测试不定序之相等性（数据存在的顺序无所谓）

bool is_permutation(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 beg);

bool id_permutation(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 beg,CompFunc op);

//查找第一次不同

pair

//检验是否排序

bool is_sorted(ForwardIterator beg,ForwardIterator end);

bool is_sorted(ForwardIterator beg,ForwardIterator end,BinaryPredicate op);

ForwardIterator is_sorted_until(ForwardIterator beg,ForwardIterator end);

ForwardIterator is_sorted_until(ForwardIterator beg,ForwardIterator end,BinaryPredicate op);

//检验是否形成Heap

bool is_heap(RandomAccessIterator beg,RandomAccessIterator end);

bool is_heap(RandomAccessIterator beg,RandomAccessIterator end);

RandomAccessIterator is_heap_until(RandomAccessIterator beg,RandomAccessIterator end);

RandomAccessIterator is_heap_until(RandomAccessIterator beg,RandomAccessIterator end,BinaryPredicate op);

//检验ALL,NONE,ANY

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

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

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 move(InputIterator sourceBeg,InputIterator sourceEnd,OutputIterator destBeg);

BidirectionalIterator2 move_backward(BidirectionalIterator1 sourceBeg,BidirectionIterator1 sourceEnd,BidircectionIterator2,destEnd);//反向

//单序列元素处理并写入目标区间

OutputIterator transform(InputIterator sourceBeg,InputIterator sourceEnd,outputIterator destBeg,UnaryFunc op);

//两序列元素结合并写入目标区间

OutputIterator transform(InputIterator1 sourceBeg,InputIterator1 sourceEnd,InputIterator2 sourceBeg,OutputIterator destBeg,BinaryFunc op);

//元素互换

ForwardIterator2 swap_ranges(ForwardIterator1 beg,ForwardIterator1 end,ForwardIterator2 beg2);

//元素赋值

void fill(ForwardIterator beg,ForwardIterator end,const T& elem);

void fill_n(Forwarditerator beg,Size num,const T& elem);

//替换元素

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

void relplace_if(ForwardIterator beg,ForwardIterator end,UnaryPredicate op,const T& value);

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,UnaryPreicate 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& elem);

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);

//复制过程中移除重复元素

OutputIterator unique_copy(InputIterator sourceBeg,InputIterator sourceBeg,OutputIterator destBeg);

OutputIterator unique_copy(InputIterator sourceBeg,InputIterator sourceEnd,OutputIterator destBeg,BinaryPredicate op);

- 变序型算法

//反转元素次序

void reverse(BidirectionalIterator beg,BidiectionalIterator end);

void reverse_copy(BidirectionalIterator sourceBeg,BidirectionalIterator sourceEnd,OutputIterator destEnd);

//对容器内的元素重新洗牌

void random_shuffle(RandomAccessIterator beg,RandomIterator end);

- 排序算法

//对所有元素排序

void sort(RandomAccessIterator beg,RandomAccessIterator end);

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

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

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

//局部排序（将beg到sortEnd的元素排序）

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

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

//Heap算法

void make_heap(RandomAccessIterator beg,RandomAccessIterator end);

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

void push_heap(RandomAccessIterator beg,RandomAccessIterator end); //容器先push，heap再push_heap

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

void pop_heap(RandomAccessIterator beg,RandomAccessIterator end); //heap再pop_heap，容器再pop

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

- 已排序区间算法

//查找元素

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

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

bool lower_bound(ForwardIterator beg,ForwardIterator end,const T& value); //返回第一个存在的位置

bool upper_bound(ForwardIterator beg,ForwardIterator end,const T& value); //返回最后一个存在的位置

pair

//合并元素

OutputIterator merge(InputIterator sourceBeg,InputIterator sourceEnd,InputIterator source2Beg,InputIterator source2End,OutputIterator destBeg); //合并两个集合的元素，包括汇总，并集，交集的处理

OutputIterator set_union(InputIterator source1Beg,InputIterator source1End,InputIterator source2Beg,InputIterator source2End,OutputIterator destBeg); //合并两个已排序集合的并集

OutputIterator set_intersection(InputIterator source1Beg,InputIterator source1End,InputIterator source2Beg,InputIterator source2End,OutputIterator destBeg); //合并两个已排序元素的交集

OutputIterator set_difference(InputIterator source1Beg,InputIterator source1End,InputIterator source2Beg,InputIterator source2End,OutputIterator destBeg); //合并两个已排序元素的差集

- 数值算法

T accumulate(InputIterator beg,InputIterator end,T initValue); //求和

T inner_product(InputIterator1 beg,InputIterator1 end,InputIterator2 beg2,T initvalue); //求积

OutputIterator partial_sum(InputIterator sourceBeg,InputIterator sourceEnd,OutputIterator destBeg); //将相对数值转换为绝对数值

```

原文地址：https://www.cnblogs.com/ukernel/p/9191139.html

时间： 2024-08-02 09:11:56

C++标准库（三）之STL算法的相关文章

STL笔记（6）标准库：标准库中的排序算法

STL笔记(6)标准库:标准库中的排序算法 标准库:标准库中的排序算法The Standard Librarian: Sorting in the Standard Library Matthew Austern http://www.cuj.com/experts/1908/austern.htm?topic=experts 用泛型算法进行排序    C++标准24章有一个小节叫“Sorting and related operations”.它包含了很多对已序区间进行的操作,和三个排序用泛型

Go语言开发（十三）、Go语言常用标准库三

Go语言开发(十三).Go语言常用标准库三 一.sync 1.sync简介 sync提供基本的同步原语,如sync.Mutex,sync.RWMutex,sync.Once,sync.Cond,sync.Waitgroup,除了Once和WaitGroup类型外,大多数类型都供低级库使用.Go语言中,不要通过共享内存通信,而要通过通信共享内存,通过Channel和沟通可以更好地完成更高级别的同步. type Locker interface { Lock() Unlock() } Locker提

C++标准库和stl区别

C++库目录:开发工具和语言-visual studio文档-visual C++-参考信息-库参考-standard C++ library C#库目录:C#使用.NET Framework 类库..NET开发-.NET Framework SDK-.NET Framwork-.NET Framework 类库 C++标准库的内容分为10类: C1.语言支持 C2.输入/输出 C3.诊断 C4.一般工具 C5.字符串 C6.容器 C7.迭代器支持 C8.算法 C9.数值操作 C10.本地化 又

C++ 标准模板库介绍（STL）

1. STL 基本介绍 C++ STL(标准模板库)是惠普实验室开发的一系列软件的统称,是一套功能强大的 C++ 模板类.STL的目的是为了标准化组件,这样就不用重新开发,让后来者可以使用现成的组件,和开源组件有点殊途同归. STL的版本很多,常见的有HP STL.PJ STL. SGI STL等,另外,STL库属于C++标准库的一部分,两者是包含关系. 由于我平时的编程环境主要在Linux系统下,所以在后面总结中,我会主以GNU ISO C++ Library中的STL源码(5.2.1版本)为

STL算法设计理念 - 函数对象和函数对象当參数和返回值

函数对象: 重载函数调用操作符的类.其对象常称为函数对象(function object),即它们是行为类似函数的对象. 一个类对象,表现出一个函数的特征,就是通过"对象名+(參数列表)"的方式使用一个类对象,假设没有上下文,全然能够把它看作一个函数对待. 这是通过重载类的operator()来实现的. "在标准库中.函数对象被广泛地使用以获得弹性".标准库中的非常多算法都能够使用函数对象或者函数来作为自定的回调行为: demo #include <iostr

STL算法设计理念 - 函数对象和函数对象当参数和返回值

函数对象: 重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象.一个类对象,表现出一个函数的特征,就是通过"对象名+(参数列表)"的方式使用一个类对象,如果没有上下文,完全可以把它看作一个函数对待. 这是通过重载类的operator()来实现的. "在标准库中,函数对象被广泛地使用以获得弹性",标准库中的很多算法都可以使用函数对象或者函数来作为自定的回调行为: demo #include <iostrea

STL 算法中函数对象和谓词

STL 算法中函数对象和谓词 函数对象和谓词定义 函数对象: 重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象.一个类对象,表现出一个函数的特征,就是通过"对象名+(参数列表)"的方式使用一个类对象,如果没有上下文,完全可以把它看作一个函数对待.          这是通过重载类的operator()来实现的.          "在标准库中,函数对象被广泛地使用以获得弹性",标准库中的很多算法都可以使用函数

第32课 - 初探C++ 标准库

第32课 - 初探C++ 标准库 1. 有趣的重载 操作符 << 的原生意义是按位左移,例: 1  <<  2 ; 其意义是将整数 1 按位左移 2 位,即: 0000 0001   ->    0000 0100 重载左移操作符,将变量或常量左移到一个对象中! 1 #include <stdio.h> 2 3 const char endl = '\n'; 4 5 class Console 6 { 7 public: 8 Console& operat

Python标准库——走马观花

Python标准库——走马观花 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python有一套很有用的标准库(standard library).标准库会随着Python解释器,一起安装在你的电脑中的.它是Python的一个组成部分.这些标准库是Python为你准备好的利器,可以让编程事半功倍. 我将根据我个人的使用经验中,挑选出标准库三个方面的包(package)介绍: Python增强 系统互动 网络 第一类:Pyth

标准库priority_queue的一种实现

优先级队列相对于普通队列,提供了插队功能,每次最先出队的不是最先入队的元素,而是优先级最高的元素. 它的实现采用了标准库提供的heap算法.该系列算法一共提供了四个函数.使用方式如下: 首先,建立一个容器,放入元素: vector<int> coll; insertNums(coll, 3, 7); insertNums(coll, 5, 9); insertNums(coll, 1, 4); printElems(coll, "all elements: "); 打印结果