STL常用总结

合集下载

stl常用函数

stl常用函数

stl常用函数STL(StandardTemplateLibrary)是C++标准库中的一个重要部分,它提供了许多常用的数据结构和算法,方便了程序员的开发工作。

在STL中,有许多常用的函数,本文将介绍一些常用的STL函数。

1. vectorvector是STL中最常用的容器之一,它是一个动态数组,可以方便地进行插入、删除等操作。

下面是一些常用的vector函数:1.1 push_backpush_back函数用于在vector的末尾添加一个元素,例如:```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);```这样,vec中就包含了1、2、3这三个元素。

1.2 pop_backpop_back函数用于删除vector末尾的一个元素,例如:```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);vec.pop_back();```这样,vec中就只包含了1、2这两个元素。

1.3 sizesize函数用于返回vector中元素的个数,例如: ```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);cout << vec.size() << endl;```输出结果为3。

1.4 clearclear函数用于清空vector中的所有元素,例如: ```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);vec.clear();```这样,vec就不包含任何元素了。

2. listlist是STL中另一个常用的容器,它是一个双向链表,可以方便地进行插入、删除等操作。

stl string常用函数

stl string常用函数

STL String常用函数STL String是C++中的一个非常重要的字符串类,它提供了许多函数来处理字符串。

在这篇文章中,我们将介绍STL String的常用函数,包括字符串的创建、修改、查找和比较等。

一、创建字符串1.构造函数STL String有多种构造函数,可以用来创建字符串。

其中,最常用的构造函数是默认构造函数,它创建一个空字符串:```c++string str; //创建一个空字符串```还可以使用其他构造函数来创建字符串,如:```c++string str1("Hello"); //使用字符串字面值创建字符串string str2(str1); //使用另一个字符串创建字符串string str3(5, 'A'); //创建一个包含5个'A'字符的字符串```2.赋值函数STL String还提供了多种赋值函数,可以用来将一个字符串赋值给另一个字符串。

其中,最常用的赋值函数是赋值运算符:```c++string str1 = "Hello";string str2 = str1;```还可以使用其他赋值函数,如:```c++string str3;str3.assign("Hello"); //将字符串字面值赋值给字符串str3.assign(str1); //将另一个字符串赋值给字符串str3.assign(5, 'A'); //将5个'A'字符赋值给字符串```二、修改字符串1.插入函数STL String提供了多种插入函数,可以用来在字符串中插入字符或子字符串。

其中,最常用的插入函数是insert()函数:```c++string str = "Hello";str.insert(1, "i"); //在第1个字符位置插入字符"i"```还可以使用其他插入函数,如:```c++string str1 = "Hello";str1.insert(1, "i", 1); //在第1个字符位置插入字符"i"的第1个字符str1.insert(1, 3, 'A'); //在第1个字符位置插入3个'A'字符str1.insert(str1.begin() + 1, 'i'); //在第1个字符位置插入字符"i"str1.insert(str1.begin() + 1, str); //在第1个字符位置插入另一个字符串str1.insert(str1.begin() + 1, str.begin(), str.end());//在第1个字符位置插入另一个字符串的一部分```2.删除函数STL String提供了多种删除函数,可以用来删除字符串中的字符或子字符串。

stl容器经典算法总结.

stl容器经典算法总结.

经典STL算法说明includes、set_difference、set_intersection、set_symmetric_difference、set_union, pre_permutation, next_permutation,min_element,max_element,sort最后自定义一个C++通过归并的方式求交集和并集includes说明:测试有序序列中是否包含另一个序列的全部元素template<class inputIterator1, class inputIterator2>bool includes(inputIterator1 first1, inputIterator1 last1,inputIterator2 first2, inputIterator2 last2;template<class inputIterator1 , class inputIterator2, class Comp>bool includes(inputIterator1 first1, inputIterator1 last1,inputIterator2 first2, inputIterator2 last2,Comp cmp;注意:两个序列必须都是排序的且相同的排序,Comp必须和两个序列用相同的排序函数对象。

建议:鉴于以上特点,用std::set 作为容器比较好set_differrence说明:◆set_difference(算法计算两个集合[start1, end1和[start2, end2的差集, 并将差集存放到result.两个集合以序列的形式给出, 且必须先按升序排好位置◆ set_difference(是一个指向result序列末尾的迭代器◆如果严格弱排序的比较函数对象cmp未指定, set_difference(将使用<操作符比较元素◆包含在第一个有序集合中,但不包含第二个有序集合中的元素,这些不同的元素复制到最后一个参数中,最后一个参数是一个保存这些元素的容器的首迭代器,这个容器必须预先分配足够的空间来容纳元素。

STL的入门知识

STL的入门知识

Adaptor(适配器)模式

定义:将一个类的界面转换为另一个类的界 面,使原本因界面不相容而不能合作的 classes,可以一起运作。
Adaptor模式

在STL中,改变iterator界面的叫做iterator adaptor 改变container界面的叫做container adaptor, 改变function object界面的叫做function adaptor
关联式容器

Maps/Multimaps
用map/multimap前,必 须包含头文件<map>
便捷函 数,返 回一个 pair对象
容器的共通能力
所有容器提供的都是value语意,而非 reference语意。容器执行插入元素的操 作时,内部实施拷贝动作。所以STL容 器内存储的元素必须能够被拷贝(必须 提供拷贝构造函数)。 每个容器都提供可返回迭代器的函数, 运用返回的迭代器就可以访问元素。 通常STL不会丢出异常。要求使用运行 者对确保传入正确的参数。

迭代器的基本操作
用法和指针一样, 其实指针就是一 种迭代器
运算符 重载
迭代器(Iterator)简述

迭代器示例
关联式容器

Sets/Multisets
– 内部的元素依据其值自动排序 – Set(集合容器)内的相同数值的元素只能 出现一次,Multisets(多重集合容器)内 可包含多个数值相同的元素。


Container Adaptor


STL提供的另两种容器queue、stack,其实 都只不过是一种adaptor,它们简单地修饰 deque的界面而成为另外的容器类型 STL的源码

STL讲解

STL讲解
}
Map映射
映射,顾名思义就是一个数映射(指向)另一个数,或者几个数映射一个数。 比如:13 (1映射3); (1,2)3 ( (1,2)这对数映射到3上),但是不能多重映射,即 13,然后不能再有12这个关系了; 而multimap也是映射,但是允许多重映射,比如上面说的1可以映射到3,也可以同时映 射到2上。 如: map[键]=值。这种形式就是映射关系(看起来与一维数组很像,很多时候可以作为一 维数组使用,哈哈……) Map中的键值默认是从小到大排序的。 他们的成员函数都是一样的(和set与multiset的关系相似,可能有的函数返回值不一样) : begin() 返回指向map头部的迭代器 clear() 删除所有元素 count() 返回指定元素出现的次数 empty() 如果map为空则返回true end() 返回指向map末尾的迭代器 erase() 删除一个元素 find() 查找一个元素 insert() 插入元素 size() 返回map中元素的个数 swap() 交换两个map lower_bound() 返回键值>=给定元素的第一个位置 upper_bound() 返回键值>给定元素的第一个位置
vector
成员函数: 举例:vector<int> c ; c.back() 传回最后一个数据,不检查这个数据是否存在。 c.begin() 传回迭代器中的第一个数据地址。 c.clear() 移除容器中所有数据。 c.empty() 判断容器是否为空。 c.end() // 指向迭代器中末端元素的下一个,指向一个不存在元素。 c.erase(pos) // 删除pos位置的数据,传回下一个数据的位置。 c.erase(beg,end) 删除[beg,end)区间的数据,传回下一个数据的位置。 c.front() 传回第一个数据。 c.insert(pos,elem) // 在pos位置插入一个elem拷贝,传回新数据位置 c.insert(pos,n,elem) // 在pos位置插入n个elem数据,无返回值 c.insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值 c.max_size() 返回容器中最大数据的数量。 c.pop_back() 删除最后一个数据。 c.push_back(elem) 在尾部加入一个数据。 c.resize(num) 重新指定队列的长度。 c.reserve() 保留适当的容量。 c.size() 返回容器中实际数据的个数。

STL学习总结大全

STL学习总结大全

STL就是S‎t andar‎d Templa‎t e Librar‎y,标准模板库。

这可能是一个‎历史上最令人‎兴奋的工具的‎最无聊的术语‎。

从根本上说,STL是一些‎“容器”的集合,这些“容器”有list, vector‎,set,map等,STL也是算‎法和其它一些‎组件的集合。

这里的“容器”和算法的集合‎指的是世界上‎很多聪明人很‎多年的杰作。

是C++标准库的一个‎重要组成部分‎,它由Step‎a nov and Lee等人最‎先开发,它是与C++几乎同时开始‎开发的;一开始STL‎选择了Ada‎作为实现语言‎,但Ada有点‎不争气,最后他们选择‎了C++,C++中已经有了模‎板。

STL又被添‎加进了C++库。

1996年,惠普公司又免‎费公开了ST‎L,为STL的推‎广做了很大的‎贡献。

STL提供了‎类型安全、高效而易用特‎性的STL无‎疑是最值得C‎++程序员骄傲的‎部分。

每一个C++程序员都应该‎好好学习ST‎L。

大体上包括c‎o ntain‎e r(容器)、algori‎t hm(算法)和itera‎t or(迭代器),容器和算法通‎过迭代器可以‎进行无缝连接‎。

一、基础知识1、泛型技术泛型技术的实‎现方法有多种‎,比如模板,多态等。

模板是编译时‎决定,多态是运行时‎决定,其他的比如R‎T TI 也是运‎行时确定。

多态是依靠虚‎表在运行时查‎表实现的。

比如一个类拥‎有虚方法,那么这个类的‎实例的内存起‎始地址就是虚‎表地址,可以把内存起‎始地址强制转‎换成int*,取得虚表,然后(int*)*(int*)取得虚表里的‎第一个函数的‎内存地址,然后强制转换‎成函数类型,即可调用来验‎证虚表机制。

泛型编程(generi‎c progra‎m ming,以下直接以G‎P称呼)是一种全新的‎程序设计思想‎,和OO,OB,PO这些为人‎所熟知的程序‎设计想法不同‎的是GP抽象‎度更高,基于GP设计‎的组件之间偶‎合度底,没有继承关系‎,所以其组件间‎的互交性和扩‎展性都非常高‎。

stl常用算法

stl常用算法

stl常用算法
STL(StandardTemplateLibrary)是C++的一种标准库,其中包含了许多常用的算法。

以下是STL中常用的算法:
1. sort:排序算法,可对数组或容器进行排序。

2. find:在容器中查找某个元素,返回该元素的迭代器。

3. count:统计容器中某个元素的个数。

4. max/min:返回容器中最大/最小元素的迭代器。

5. accumulate:对容器中的元素进行累加操作。

6. reverse:将容器中的元素反转。

7. unique:去重,将容器中重复的元素去除。

8. transform:对容器中的元素进行转换操作。

9. copy:将一个容器中的元素复制到另一个容器中。

10. fill:将容器中的元素全部赋值为指定值。

以上是STL中常用的算法,它们提供了一些方便的方法来操作容器中的元素。

在实际开发中,我们可以根据需要选择合适的算法来解决问题。

- 1 -。

STL基础学习(STL中的容器解析代码展示例题分析,帮助你学STL)

STL基础学习(STL中的容器解析代码展示例题分析,帮助你学STL)

STL就是Standard Template Library(C++标准模板库),下面是关于STL中的各种内容STL中的几个基本概念:1.容器:可容纳各种数据类型的数据结构。

可以用于存放各种类型的数据(基本类型的变量,对象等)的数据结构。

容器分为三大类:(1) 顺序容器vector:后部插入/删除,直接访问deque:前/后部插入/删除,直接访问list:双向链表,任意位置插入/删除1) vector 头文件<vector>实际上就是个动态数组。

随机存取任何元素都能在常数时间完成。

在尾端增删元素具有较佳的性能。

2) deque 头文件<deque>也是个动态数组,随机存取任何元素都能在常数时间完成(但性能次于vector)。

在两端增删元素具有较佳的性能。

3) list 头文件<list>双向链表,在任何位置增删元素都能在常数时间完成。

不支持随机存取。

上述三种容器称为顺序容器,是因为元素的插入位置同元素的值无关。

(2)关联容器set:快速查找,无重复元素multiset :快速查找,可有重复元素map:一对一映射,无重复元素,基于关键字查找multimap :一对一映射,可有重复元素,基于关键字查找,前2者合称为第一类容器关联式容器内的元素是排序的,插入任何元素,都按相应的排序准则来确定其位置。

关联式容器的特点是在查找时具有非常好的性能。

1) set/multiset: 头文件<set>set 即集合。

set中不允许相同元素,multiset中允许存在相同的元素。

2) map/multimap: 头文件<map>map与set的不同在于map中存放的是成对的key/value。

并根据key对元素进行排序,可快速地根据key来检索元素map同multimap的不同在于是否允许多个元素有相同的key值。

上述4种容器通常以平衡二叉树方式实现,插入和检索的时间都是O(logN)(3)容器适配器stack:LIFO queue:FIFO priority_queue:优先级高的元素先出对象被插入容器中时,被插入的是对象的一个复制品。

stl容器知识点总结

stl容器知识点总结

stl容器知识点总结一、STL容器的种类STL中的容器主要分为序列式容器(Sequence Containers)和关联式容器(Associative Containers)两大类。

序列式容器包括vector、deque、list、forward_list以及array等,而关联式容器则包括set、map、multiset、multimap和unordered_set、unordered_map、unordered_multiset、unordered_multimap等。

1. 序列式容器(1)vector:动态数组,支持随机存取,可以在尾部进行快速插入和删除操作,但在中间和头部的插入和删除效率比较低。

(2)deque:双端队列,支持随机存取,同时在头部和尾部进行快速插入和删除操作,但在中间的插入和删除效率比较低。

(3)list:双向链表,支持在任意位置进行快速插入和删除操作,但不支持随机存取。

(4)forward_list:单向链表,与list相似,但只支持单向的迭代器访问。

(5)array:固定大小的数组,提供与普通数组相似的访问和操作方式。

2. 关联式容器(1)set:集合,不允许重复的元素,并且会自动排序。

(2)map:映射,每个元素都含有一个键值对,并且键是唯一的,自动排序。

(3)multiset:多重集合,允许重复的元素,并且会自动排序。

(4)multimap:多重映射,允许重复的键值对,并且会自动排序。

(5)unordered_set:无序集合,不允许重复的元素,内部实现采用哈希表。

(6)unordered_map:无序映射,每个元素都含有一个键值对,键是唯一的,内部实现采用哈希表。

(7)unordered_multiset:无序多重集合,允许重复的元素,内部实现采用哈希表。

(8)unordered_multimap:无序多重映射,允许重复的键值对,内部实现采用哈希表。

以上就是STL中的主要容器种类,每种容器都有各自的特性和适用场景,在实际开发中需要根据具体的需求选择合适的容器进行使用。

03--STL算法(常用算法)

03--STL算法(常用算法)

03--STL算法(常⽤算法)⼀:常⽤的查找算法(⼀)adjacent_find():邻接查找在iterator对标识元素范围内,查找⼀对相邻重复元素,找到则返回指向这对元素的第⼀个元素的迭代器。

否则返回past-the-endvector<int> v1;v1.push_back(2);v1.push_back(1);v1.push_back(3);v1.push_back(3);v1.push_back(6);v1.push_back(9);v1.push_back(9);vector<int>::iterator iter = adjacent_find(v1.begin(), v1.end()); //只查找第⼀个cout << *iter << endl;(⼆)binary_search():⼆分查找在有序序列中查找value,找到则返回true。

注意:在⽆序序列中,不可使⽤(虽然不会报错,但是⽆法正常⼯作)int main(){vector<int> v1,v2;v1.push_back(3);v1.push_back(3);v1.push_back(6);v1.push_back(9);v1.push_back(8);for_each(v1.begin(), v1.end(), ShowEle<int>);cout << endl;sort(v1.begin(), v1.end());bool flag = binary_search(v1.begin(), v1.end(),8);if (flag)cout << "find 8" << endl;for_each(v1.begin(), v1.end(), ShowEle<int>);cout << endl;system("pause");return0;}注意:对于vector,deque等容器需要我们先解析排序再来查找。

STL常见函数总结

STL常见函数总结

STL常见函数总结#include<bitset>#include<deque>#include<list>#include<map>#include<set>#include<stack>#include<vector>#include<algorithm>#include<string>#include<queue>容器和算法顺序容器1 vector//支持快速随机访问vector<int> f,f1;vector<int>::iterator iter,q,h;int n,x;f.push_back(x);在尾部插入元素x,返回void;f.insert(iter,x);在iter前面插入x,返回指向新添加元素的迭代器;f.insert(iter,n,x);在iter前面插入n个x,返回void;f.insert(iter,q,h);在迭代器iter前面插入q和h范围内的所以元素; f.size(); 返回类型:vector<int>::size_type,也可直接用int,longf.empty();返回布尔值f.back();最后一个元素f.front();返回第一个元素f[n] 返回第n个元素f.erase(iter)删除iter指向的元素,返回所删除值后面的元素的迭代器,若删除的是最后一个元素返回f.end()一样的位置f.erase(q,h)删除q-h所有元素(包括q,不包括h),返回指向后面的的若h就是f.end(),还返回f.end();f.clear();清空所以元素,返回voidf.pop_back()删除最后一个元素,返回void可以直接赋值f1=f;可以直接比较大小f1=swap(f);f.assign(q,h);f先清空,然后把来自另一个vector的从q到h的元素复制进来f.assign(n,x);f先清空,然后赋为n个x2 list//支持快速插入删除,就是个链表f.push_front(x);不能用f[n]来访问f.pop_front();返回void3 deque//双端队列,两头都有vector的高效性质,还,可以实现元素的随机访问f.push_front(x);f[n];f.pop_front();返回void4 stack//后进先出栈s.empty()s.size()s.pop() 删除栈顶元素,不返回值s.top() 返回栈顶元素的值,但不删除栈顶元素s.push(x) 压栈5 queue//先进先出队列s.empty()s.size()s.pop()删除队首元素,不返回值s.front()返回队首值,但不删除s.back()返回队尾值,但不删除s.push(),在最后插入元素6 priority_queue //有优先级管理的队列s.empty()s.size()s.pop()删除队首元素,不返回值s.front()返回队首值,但不删除s.top()返回具有最高优先级的元素,但不删除s.push(),在适当位置插入新元素定义方法priority_queue<int,vector<int>,greater<int>>priority_queue<int,vector<int>,less<int>>priority_queue<int>7 string 和vector差不多其实,特殊的vector?int pos;char ch[100];getline(cin,s);s.insert(iter,t); iter前插ts.insert(iter,n,t); iter前n个插ts.insert(iter,q,h);s.earse(iter);s.earse(q,h);s.insert(pos,n,t);在pos前插入n个ts.insert(pos,s1); 在pos前插入s1s.earse(pos,n);删除pos开始的n个字符s.insert(pos,ch,n);s.insert(pos,ch);s.substr(pos,n);返回从pos开始的n个字符的字符串s.substr(pos);s.replace(pos.len.s1);删除pos开始的len个字符并以s1代替插进去s.replace(q,h,s1);s.find(s1) s1在s中第一次出现的位置s.rfind(s1) s1在s中最后一次出现的位置s.find_first_of(s1) 在s中查找s任意字符第一次出现s.find_last_of(s1) 在s中查找s任意字符最后一次出现s.find_first_not_of(s1)s.find_last_not_of(s1)每个s1都有四种重载版本 s1,pos(从pos开始找),s1,pos,n(匹配s1的前n个字母)string的比较:s==s1,s>s1,s<s1最一般的pare(s1)pare(pos,n,s1);s从pos开始的n个字符,同理,这里的s1也有多种重载版本关联容器1 map(键值对应),键要可排序类型map<string,int> f;map<string,int>::key_type 键的类型map<string,int>::mapped_type 值的类型map<string,int>::value_type pair类型,其中first为一个常量,而sencond 为一个可变量map中添加元素:直接下标添加:f["hello"]=2;(建立了键后首先赋值为0)(若原来有这个“hello”,则是修改了这个键对应的值)用insert添加新元素:f.insert(map<string,int>::value_type("hello",1));f.insert(make_pair("hello",1));insert(pair),返回一个pair类型( pair<map<string,int>::iteratro, bool> ret)对象,包括一个指向插入键的迭代器,和bool类型的判断是否插入的布尔值,如果键已经存在,就不插入了map中查找,读取元素下标读取有危险(如果没有会插入)f.count("hello") 返回”hello"出现的次数,对于map,返回的就是0或1 f.find("hello") 返回对应的迭代器,否则返回f.end()处删除元素:f.erase(),1传入键(返回0or1),2传入迭代器(void),3传入一对迭代器(void)2 setset<int> set1,set2;添加元素:set1.insert(x);set2.insert(set1.begin(),set1.end());set1.find(x);set1.count(x);set1.erase(x);1 bitsetbitset<100> f;f.any() 是否存在为1的二进制位f.none()f.size()f[n]f.test(n)f.set() 全部置为1f.set(n) 第n位置为1f.reset()全部置为0f.reset(n)f.flip()逐位取反f.flip(n)f.to_ulong()把它返回会unsigned long1 algorithmuniquefillfill_nreplacereplace_copyaccumulatesortstable_sortcount_if……。

STL中的算法总结

STL中的算法总结

stl算法大致分为4类1.非可变序列算法:对容器进行操作时不会改变容器的内容。

2.可变序列算法:一般不会修改它们说操作的容器的内容。

3.排序相关算法:包括排序算法和合并算法,二分查找算法以及有序序列的集合操作算法。

4.通用数值算法。

使用的比较少。

算法包括原地形式,复制形式和判断函数参数形式。

原地形式是指算法把它对容器操作的结果存放在同一个容器,即被操作的容器中。

复制形式是指算法将操作结果复制到另外的容器中,或者复制到被操作容器的另一个不重叠的部分中。

判断函数参数形式是指以一个函数作为参数的形式,这类函数通常是以类的形式定义的函数对象,这种函数表示形式可以提高函数参数传递的效率,因为函数的传递可以在编译时进行。

1.非可变序列算法:包括find,adjacent_find,count,for_each,mismarch,equal和search。

1.1 findfind有find和find_if两种形式find的形式为: template<class _II, class _Ty> inline _II find(_II _F, _II _L, const _Ty& _V) {for (; _F != _L; ++_F) if (*_F == _V) break; return (_F); }find_if的形式为 template<class _II, class _Pr> inline _II find_if(_II _F, _II _L, _Pr _P) {for (; _F != _L; ++_F) if (_P(*_F)) break; return (_F); } 查找满足条件_Pr的结果通常class _Pr的定义如下: class GreaterThan50 { public: bool operator()(int)const{return x>50;} };函数的调用如下: int main(){vectro<int>vectorl;for(int i = 0; i != 13; ++i)vectorl.push_back(i*i);vector<int>::iterator where;where = find_if(vectorl.begin(),vectorl.end,GreaterThan50());return 0;}1.2 adjacent_find adjacent_find算法在序列种查找相邻且相等的两个元素,当找到这样的两个元素时,该算法返回指向两个元素中的第一个迭代器。

STL的常用算法

STL的常用算法

STL的常用算法该篇分为十一部分,分别是:vector类的主要成员、deque类的主要成员、list 类的主要成员、stack类的主要成员、queue类的主要成员、priority_queue类的组要成员、set 类的主要成员、multiset类的主要成员、map类的主要成员、multimap类的主要成员、STL算法函数(一)vector类的主要成员vector<T>是可边长的向量,比较灵活☆ value_type;//对象类型T,存储在vector中 [定义地方:容器]☆ pointer;//指向T的指针 [容器]☆ reference;//T的引用 [容器]☆ const_reference;//T的常量引用 [容器]☆ size_type;//正整数类型 [容器]☆ difference_type;//整数类型 [容器]☆ iterator ;//访问vector的迭代器 [容器]☆ const_iterator;//访问vector的常量迭代器 [容器]☆ reverse_iterator;//访问vector的反向迭代器 [Reversible容器]☆ const_reve rse_iterator;//访问vector的反向迭代器 [Reversible容器] ☆ iterator begin();//返回vector的头指针 [容器]☆ iterator end();//返回vector的尾指针 [容器]☆ const_iterator begin() const;//返回vector的常量头指针 [容器]☆ const_iterator end() const;//返回vector的常量尾指针 [容器]☆ reverse_iterator rbegin();//返回反向vector的反向头指针 [Reversible 容器]☆ reverse_iterator rend();//返回反向vector的反向尾指针 [Reversible 容器]☆ const reverse_iterator rbegin() const;//返回反向vector的反向常量头指针 [Reversible容器]☆ const_reverse_iterator rend() const();//返回反向vector的反向常量尾指针 [Reversible容器]☆ size_type s ize() const;//返回vector的元素数量 [容器]☆ size_type max_size() const;// 返回最大可允许的vector元素数量值 [容器]☆size_type capacity() const;//返回当前所能容纳的最多元素个数 [vector] ☆bool empty() const;//判断vector是否为空 [容器]☆reference operator[](size_type n); //返回第n个元素 [Random Access 容器]☆const_reerence operator[](size_type n)const; //返回第n个元素 [Random Access容器]☆vector();//创建一个空vector [容器]☆vector(size_type n);//创建一个vector,元素数量为n [Sequence]☆vector(size_type n, const T& t);//创建一个vector,元素数量为n,大小都为t[Sequence]☆vector(const vector &);//拷贝构造函数 [容器]☆template<class InputIterator>vector(InputIterator, InputIterator); [Sequence]//采用拷贝的方法创建一个vector,指定了范围☆~vector();// vector的析构函数 [容器]☆vector& operator=(const vector&);//=运算符重载 [容器]☆void reserve(size_t n);//为vector预先分配n个元素 [vector]☆reference front();// 返回第一个元素 [Sequence]☆const_reference front() const;//返回第一个元素 [Sequence]☆reference back();//返回最后一个元素 [Back Insertion Sequence]☆const_reference back() const;//返回最后一个元素 [Back Insertion Sequence]☆void push_back(const T&);//在vector尾部插入一个元素 [Back Insertion Sequence]☆void pop_back();//删除最后一个元素 [Back Insertion Sequence]☆void swap(vector&);//交换两个vector的内容 [容器]☆iterator insert(iterator pos, const T& x);//在pos前出入x [Sequence] ☆template<class InputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);//在位置pos位置前插入范围为[fisrt, last]的元素 [Sequence]☆void insert(iterator pos, size_type n, const T& x);//在位置pos前出入n个x [Sequence]☆iterator erase(iterator pos);//删除在位置pos的元素 [Sequence]☆iterator erase(iterator first, iterator last);//删除在[first, last]之间的元素 [Sequence]☆void clear();//删除所有的元素 [Sequence]☆void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t[Sequence]☆bool operator==(const vector&, const vector&);//重载==运算符 [Forward 容器]☆bool operator<(const vector&, const vector&);//小于逻辑运算符[Forward容器]vector类的私有成员:☆size_type capacity() const;//返回当前所能容纳的最多元素个数,其值不小于size()☆void reserve(size_type n);//如果n小于或等于capacity(),本函数没有作用。

STL中的常用的vector,map,set,Sort用法笔记

STL中的常用的vector,map,set,Sort用法笔记

C++的标准模板库(Standard Template Library,简称STL)是一个容器和算法的类库。

容器往往包含同一类型的数据。

STL中比较常用的容器是vector,set和map,比较常用的算法有Sort等。

.一. vector1.声明:一个vector类似于一个动态的一维数组。

vector<int> a; //声明一个元素为int类型的vector avectot<MyType> a; //声明一个元素为MyType类型的vector a这里的声明的a包含0个元素,既a.size()的值为0,但它是动态的,其大小会随着数据的插入和删除改变而改变。

vector<int> a(100, 0); //这里声明的是一已经个存放了100个0的整数vector 2.向量操作常用函数:size_t size(); // 返回vector的大小,即包含的元素个数void pop_back(); // 删除vector末尾的元素,vector大小相应减一void push_back(); //用于在vector的末尾添加元素T back(); // 返回vector末尾的元素void clear(); // 将vector清空,vector大小变为0其他访问方式:cout<<a[5]<<endl;cout<<a.at(5)<<endl;以上区别在于后者在访问越界时会抛出异常,而前者不会。

例:int intarray[10];vector<int> first_vector(intarray, intarray + 10);vector<int> second_vector(first_vector.begin(),first_vector.end());class man{public:AnsiStirng id;AnsiString mc;}vector<man> manList;man thisman;thisman.id="2001";="yourname";manList.push_back thisman; //加入第一个元素thisman.id="2002";="myname";manList.push_back thisman; //加入第二个元素manList.clear(); //清空3.遍历(1). for(vector<datatype>::iterator it=a.begin(); it!=a.end();it++)cout<<*it<<endl;(2). for(int i=0;i<a.size;i++)cout<<a[i]<<endl;二. mapMap是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性map内部的实现自建一颗红黑树(一种非严格意义上的平衡二叉树),这颗树具有对数据自动排序的功能。

STL标准库-算法-常用算法

STL标准库-算法-常用算法

STL标准库-算法-常⽤算法技术在于交流、沟通,本⽂为博主原创⽂章转载请注明出处并保持作品的完整性介绍11种STL标准库的算法,从这11种算法中总结⼀下算法的基本使⽤1.accumulate() 累加2.for_each() for⼀段区间做你指定的⾏为3.replace(), replace_if(), replace_copy() 替换函数4.count(), count_if() 计数5.find() 查找6.sort() 排序7.binary_search()查看元素是否在指定区间下⾯的仿函数都没有继承⾃ binary_function<T,T,bool>, unary_function<T,bool>,但是在实际操作中,声明仿函数⼀定要继承⾃binary_function<T,T,bool>,unary_function<T,bool>下⼀节内容会介绍为什么要继承⾃这两个类⼀ accumulate(),累加,将指定区域内的value累加起来源码及参数介绍//默认累加算法,将传进的__first(begin()迭代器)位置,⾄__last(end()迭代器),与init求和template<typename _InputIterator, typename _Tp>inline _Tpaccumulate(_InputIterator __first, _InputIterator __last, _Tp __init){// concept requirements__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)__glibcxx_requires_valid_range(__first, __last);for (; __first != __last; ++__first)__init = __init + *__first;return __init;}//⾃定义accumulate 按照指定的要求做”累加”操作template<typename _InputIterator, typename _Tp, typename _BinaryOperation>inline _Tpaccumulate(_InputIterator __first, _InputIterator __last, _Tp __init,_BinaryOperation __binary_op){// concept requirements__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)__glibcxx_requires_valid_range(__first, __last);for (; __first != __last; ++__first)__init = __binary_op(__init, *__first);return __init;}View Code基本使⽤#include <iostream>#include <functional>#include <numeric>#include <vector>#include <algorithm>using namespace std;namespace wzj000 {int myfunc(int x, int y) {return x+2*y;}struct myclass{int operator()(int x, int y){return x+3*y;}};void test_accumulate(){int init = 100;int num[] {10, 20, 30};cout<<"default accumulate: " << accumulate(num, num+3, init)<< endl; //100 + 10 + 20 + 30 默认累加cout << "using minus: " << accumulate(num, num+3, init, minus<int>())<< endl; //100 - 10 - 20 - 30 将累加改为递减cout << "using custom function: " << accumulate(num, num+3, init, myfunc)<< endl; // 100 + 2*10 + 2*20 + 2*30 ⾃定义"累加"规则 funccout << "suing custom object: " << accumulate(num, num+3, init, myclass())<< endl; // 100 + 3*10 + 3*20 + 3*30⾃定义"累加"规则仿函数}}测试结果源码及参数介绍template <class Inputerator, class Function>Function for_each(Inputerator first, Inputerator last, Function f) {//参数1 起始点参数2 终点, 参数3 想要执⾏的操作for( ; first != last; ++first){f(*first);}return f;}View Code基本使⽤namespace wzj001 {void myfunc(int i){cout << " - " << i;}struct myclass{void operator()(int i){cout << " ^ " << i;}};void test_for_each(){vector<int> myVector = {10, 20, 30};for_each(myVector.begin(), myVector.end(), myfunc);cout << endl;}void test_for_each_classFunc(){vector<int> myVector = {10, 20, 30};for_each(myVector.begin(), myVector.end(), myclass()); cout << endl;}}测试结果三 replace() 替换函数replace_if() replace_copy()源码及参数介绍template <class ForwardIterator, class T>void replace(Inputerator first, Inputerator last, const T & old_value, const T& new_value){//范围内所有等于old_value者都⼀new_value取代for( ; first != last; ++first){if(*first == old_value)*first = new_value;}}template <class Inputerator, class Inputerator, class T>void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value){//范围内所有满⾜pred()为true之元素都以new_value取代for( ; first != last; ++first){if(pred(*first))*first = new_value;}}template <class Inputerator, class Outputerator, class T>Outputerator replace_copy(ForwardIterator first, ForwardIterator last, Outputerator result, const T & old_value, const T& new_value) {//范围内所有等于old_value者都以new_value放置新区域//不符合者原值放⼊新区域for( ; first != last; ++first, ++result){*result = *first == old_value ? new_value : *first;}}View Code基本使⽤namespace wzj002 {struct myclass{bool operator()(int i){return i >=10 ? true : false;}};void test_replace(){vector<int> myVector = {10, 20, 30};replace(myVector.begin(), myVector.end(), 20 ,30);cout << "replace: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_replace_if(){vector<int> myVector = {10, 20, 30};replace_if(myVector.begin(), myVector.end(), myclass(), 30);cout << "replace_if: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_replace_copy(){vector<int> myVector = {10, 20, 30};vector<int> myNewVector;myNewVector.resize(3);replace_copy(myVector.begin(), myVector.end(), myNewVector.begin(), 20, 10);cout << "replace_if_New: ";for(auto i : myNewVector){cout << i << "";}cout << endl;cout << "replace_if_Old: ";for(auto i : myVector){cout << i << "";}cout << endl;}}测试结果四 count() 计数count_if()源码及参数介绍template <class Inputerator, class Outputerator, class T>typename iterator_traits<Inputerator>::difference_type;count(Inputerator first, Inputerator last, const T& value){typename iterator_traits<Inputerator>::difference_type;for( ; first != last; ++first)if(*first == value) //满⾜要求值 == value 累计+1++n;return n;}template <class Inputerator, class Outputerator, class Predicate>typename iterator_traits<Inputerator>::difference_type;count_if(Inputerator first, Inputerator last, Predicate pred){typename iterator_traits<Inputerator>::difference_type;for( ; first != last; ++first)if(pred(*first)) //满⾜指定要求累计 +1++n;return n;}View Codecount()和count_if()是全局算法,适⽤于array,vector,list,forward_list, dequemap,set,unordered_set/map由于是关联式容器,所有有⾃⼰的count()和count_if()函数基本使⽤namespace wzj003 {struct myclass{bool operator()(int i){return i >= 20;}};void test_count(){vector<int> myVector = {10, 20, 30};cout << "count(): "<< count(myVector.begin(), myVector.end(), 20) <<endl;}void test_count_if(){vector<int> myVector = {10, 10, 20, 20, 30, 30};cout << "count_if(): " << count_if(myVector.begin(), myVector.end(), myclass()) <<endl;}}测试结果五 find() 查找 find_if()find()和find_if()是全局算法,适⽤于array,vector,list,forward_list, dequemap,set,unordered_set/map由于是关联式容器,所有有⾃⼰的find()和find_if()函数源码及参数介绍template <class Inputerator, class T>Inputerator find_if(Inputerator first, Inputerator last, const T& value){while(first != last && *first != value)++first;return first;}template <class Inputerator, class Predicate>Inputerator find_if(Inputerator first, Inputerator last, Predicate pred){while(first != last && !pred(*first))++first;return first;}基本使⽤namespace wzj004 {struct myclass{bool operator()(int i){return i >= 30;}};void test_find(){vector<int> myVector = {10, 20, 30};auto tmp = find(myVector.begin(), myVector.end(), 20);cout << "find(): "<< distance(myVector.begin(), tmp) <<endl;}void test_find_if(){vector<int> myVector = {10, 20, 30};auto tmp = find_if(myVector.begin(), myVector.end(), myclass());cout << "find_if(): " << distance(myVector.begin(), tmp)<<endl;}}测试结果六 sort 排序list和forward_list有成员sort()函数set/map⾃动排序array,vector,deque⽤全局sort()namespace wzj005 {struct myclass{bool operator()(int i, int y){return i > y;// sort默认降序, ⾃定义为升序}};void test_sort(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80}; sort(myVector.begin(), myVector.end());cout << "sort: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_sort_if(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80}; sort(myVector.begin(), myVector.end(), myclass());cout << "sort_if: ";for(auto i : myVector){cout << i << "";}cout << endl;}}测试结果七 binary_search()查看元素是否在指定区间内源码及参数介绍template <class Inputerator, class T>bool binary_search(Inputerator first, Inputerator last, const T& val){//返回元素是否在指定区间first = std::lower_bound(first,last,val);return (first != last && !(val < *first));}View Code基本使⽤namespace wzj006 {struct myclass{bool operator()(int i, int y){return i > y;}};void test_binary_search(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80};cout <<"binary_search: " << (binary_search(myVector.begin(), myVector.end(), 50) ? "true" : "false") << endl;}}测试结果全部测试代码#include <iostream>#include <functional>#include <numeric>#include <vector>#include <algorithm>using namespace std;namespace wzj000 {int myfunc(int x, int y) {return x+2*y;}struct myclass{int operator()(int x, int y){return x+3*y;}};void test_accumulate(){int init = 100;int num[] {10, 20, 30};cout<<"default accumulate: " << accumulate(num, num+3, init)<< endl; //100 + 10 + 20 + 30 默认累加cout << "using minus: " << accumulate(num, num+3, init, minus<int>())<< endl; //100 - 10 - 20 - 30 将累加改为递减cout << "using custom function: " << accumulate(num, num+3, init, myfunc)<< endl; // 100 + 2*10 + 2*20 + 2*30 //⾃定义"累加"规则 func cout << "suing custom object: " << accumulate(num, num+3, init, myclass())<< endl; // 100 + 3*10 + 3*20 + 3*30//⾃定义"累加"规则仿函数 }}namespace wzj001 {void myfunc(int i){cout << " - " << i;}struct myclass{void operator()(int i){cout << " ^ " << i;}};void test_for_each(){vector<int> myVector = {10, 20, 30};for_each(myVector.begin(), myVector.end(), myfunc);cout << endl;}void test_for_each_classFunc(){vector<int> myVector = {10, 20, 30};for_each(myVector.begin(), myVector.end(), myclass());cout << endl;}}namespace wzj002 {struct myclass{bool operator()(int i){return i >=10 ? true : false;}};void test_replace(){vector<int> myVector = {10, 20, 30};replace(myVector.begin(), myVector.end(), 20 ,30);cout << "replace: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_replace_if(){vector<int> myVector = {10, 20, 30};replace_if(myVector.begin(), myVector.end(), myclass(), 30);cout << "replace_if: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_replace_copy(){vector<int> myVector = {10, 20, 30};vector<int> myNewVector;myNewVector.resize(3);replace_copy(myVector.begin(), myVector.end(), myNewVector.begin(), 20, 10);cout << "replace_if_New: ";for(auto i : myNewVector){cout << i << "";}cout << endl;cout << "replace_if_Old: ";for(auto i : myVector){cout << i << "";}cout << endl;}}namespace wzj003 {struct myclass{bool operator()(int i){return i >= 20;}};void test_count(){vector<int> myVector = {10, 20, 30};cout << "count(): "<< count(myVector.begin(), myVector.end(), 20) <<endl;}void test_count_if(){vector<int> myVector = {10, 10, 20, 20, 30, 30};cout << "count_if(): " << count_if(myVector.begin(), myVector.end(), myclass()) <<endl; }}namespace wzj004 {struct myclass{bool operator()(int i){return i >= 30;}};void test_find(){vector<int> myVector = {10, 20, 30};auto tmp = find(myVector.begin(), myVector.end(), 20);cout << "find(): "<< distance(myVector.begin(), tmp) <<endl;}void test_find_if(){vector<int> myVector = {10, 20, 30};auto tmp = find_if(myVector.begin(), myVector.end(), myclass());cout << "find_if(): " << distance(myVector.begin(), tmp)<<endl;}}namespace wzj005 {struct myclass{bool operator()(int i, int y){return i > y;// sort默认降序, ⾃定义为升序}};void test_sort(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80};sort(myVector.begin(), myVector.end());cout << "sort: ";for(auto i : myVector){cout << i << "";}cout << endl;}void test_sort_if(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80};sort(myVector.begin(), myVector.end(), myclass());cout << "sort_if: ";for(auto i : myVector){cout << i << "";}cout << endl;}}namespace wzj006 {struct myclass{bool operator()(int i, int y){return i > y;}};void test_binary_search(){vector<int> myVector = {10, 20, 30, 50, 70, 90, 100, 60, 80};cout <<"binary_search: " << (binary_search(myVector.begin(), myVector.end(), 50) ? "true" : "false") << endl; }}int main(int argc, char *argv[]){wzj000::test_accumulate();wzj001::test_for_each();wzj001::test_for_each_classFunc();wzj002::test_replace();wzj002::test_replace_if();wzj002::test_replace_copy();wzj003::test_count();wzj003::test_count_if();wzj004::test_find();wzj004::test_find_if();wzj005::test_sort();wzj005::test_sort_if();wzj006::test_binary_search();return0;}View Code参考侯捷<<STL源码剖析>>。

STL常用算法

STL常用算法

STL常⽤算法1.STL-常⽤算法概述:算法主要是由头⽂件#include<algorithm>``#include<functional>``#inlcude<numeric>组成#include<algorithm>是所有STL头⽂件中最⼤的⼀个,范围涉及到⽐较、交换、查找、遍历操作、复制,修改等等#include<functional>体积很⼩,只包括⼏个在序列上⾯进⾏简单数学运算的模板函数#inlcude<numeric>定义了⼀些模板类,⽤以声明函数对象2.常⽤遍历算法算法简介:for_each遍历容器transform搬运容器到另⼀个容器2.1 for_each功能描述:实现遍历容器函数原型:for_each(iterator beg,iterator end,_func);遍历算法,遍历容器元素beg开始迭代器end结束迭代器_func函数或者函数对象⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//常⽤遍历算法 fro_each//普通函数void print01(int v1){cout << v1 << " ";}//仿函数class MyPrint{public:void operator()(int val){cout << val << " ";}};void test01(){vector<int>v;for (int i = 0; i < 10; i++){v.push_back(i);}for_each(v.begin(), v.end(), print01);cout << endl;for_each(v.begin(), v.end(), MyPrint());//MyPrint()仿函数cout << endl;}int main(){test01();system("pause");return 0;}running0 1 2 3 4 5 6 7 8 90 1 2 3 4 5 6 7 8 92.2 transform功能描述:搬运容器到另⼀个容器函数原型:transform(iterator beg1,iterator end1,iterator beg2,_func);beg1源容器开始迭代器end1源容器结束迭代器beg2⽬标容器开始迭代器_func函数或者函数对象⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//transformclass Transform{public:int operator()(int val){return val+10;//也可以做⼀些逻辑规则}};class MyPrint{public:void operator()(int val){cout << val << " ";}};void test01(){vector<int>v;for(int i = 0; i < 6; i++){v.push_back(i);}vector<int>v2;//⽬标迭代器v2.resize(v.size());transform(v.begin(), v.end(), v2.begin(), Transform());//Transform()仿函数 for_each(v2.begin(), v2.end(), MyPrint());//MyPrint()仿函数cout << endl;}int main(){test01();system("pause");return 0;}running10 11 12 13 14 153.常⽤的查找算法算法简介:find查找元素find_if按条件查找元素adjacend_find查找相邻重复元素binary_search⼆分查找法count统计元素个数count_if按条件统计元素个数3.1find功能描述:查找指定元素,找到返回指定容器的迭代器,找不到返回结束迭代器end()函数原型:find(iterator beg,iterator end,value);按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置beg 开始迭代器end 结束迭代器value 查找的元素⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm> //算法的头⽂件//常⽤查找算法-- find//查找内置数据类型void test01(){vector<int>v;for (int i = 0; i < 10; i++){v.push_back(i);}//查找容器中是否有5这个数据vector<int>::iterator it = find(v.begin(), v.end(), 5);if (it == v.end()){cout << "没有找到!" << endl;}else{cout << "找到了:" << *it << endl;}}//查找⾃定义数据类型class Person{public:Person(string name, int age){this->m_age = age;this->m_name = name;}//重载“==”让底层知道如何对⽐数据类型bool operator==(const Person& p){if (this->m_name == p.m_name && this->m_age == p.m_age){return true;}else{return false;}}string m_name;int m_age;};void test02(){Person p1("孙悟空", 10);Person p2("猪⼋戒", 20);Person p3("沙和尚", 30);Person p4("唐僧", 40);Person others("孙悟空", 10);//存放到容器中vector<Person>v;v.push_back(p1);v.push_back(p1);v.push_back(p1);v.push_back(p1);vector<Person>::iterator it = find(v.begin(), v.end(), others);//查看others是否存在,返回值是⼀个迭代器 if (it == v.end()){cout << "没有找到" << endl;}else{cout << "找到了" << "姓名:" << it->m_name << " " << "年龄:" << it->m_age << endl;}}int main(){test01();test02();system("pause");return 0;}running找到了:5找到了姓名:孙悟空年龄:10find()可以在指定容器中找指定元素,返回值是迭代器3.2find_if功能描述:按条件查找元素函数原型:find_if(iterator beg,iterator end,_Pred);按值查找元素,找到返回指定位置迭代器,到不到返回结束位置迭代器_Pred 函数或谓词(返回bool类型的仿函数)⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//find_if//查找内置数据类型class GreaterFive{public:bool operator()(int val){return val > 5;//val⼤于5的情况下返回真}};void test01(){vector<int>v;for(int i = 0; i < 10; i++){v.push_back(i);}vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());//GreaterFive()仿函数 if (it == v.end()){cout << "没有找到!" << endl;}else{cout << "找到了⼤于五的数据:" << *it << endl;}}//2.查找⾃定义数据类型class Person{public:Person(string name, int age){this->m_age = age;this->m_name = name;}string m_name;int m_age;};//谓词class Greater20{public:bool operator()(Person& p){return p.m_age > 20;}};void test02(){vector<Person>v1;Person p1("孙悟空", 10);Person p2("猪⼋戒", 20);Person p3("沙和尚", 30);Person p4("唐僧", 40);v1.push_back(p1);v1.push_back(p2);v1.push_back(p3);v1.push_back(p4);//找⼀个年龄⼤于20的成员vector<Person>::iterator it = find_if(v1.begin(), v1.end(), Greater20());//Greater20()仿函数 if (it == v1.end()){cout << "没有找到" << endl;}else{cout << "找到了:" << "姓名:" << it->m_name << " 年龄:" << it->m_age << endl;}}int main(){test01();test02();system("pause");return 0;}running找到了⼤于五的数据:6找到了:姓名:沙和尚年龄:303.3adjacent_find功能描述:查找相邻重复元素函数原型:adjacent_find(iterator beg,iterator end);查找相邻重复元素,返回相邻元素的第⼀个位置的迭代器⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//adjacent_find()查找相邻重复元素void test01(){vector<int>v;v.push_back(0);v.push_back(1);v.push_back(2);v.push_back(0);v.push_back(0);v.push_back(4);v.push_back(4);vector<int>::iterator it = adjacent_find(v.begin(), v.end());if (it == v.end()){cout << "没有找到" << endl;}else{cout << "找到了:" << *it << endl;}}int main(){test01();//test02();system("pause");return 0;}running找到了:0总结:⾯试题中如果出现了查找相邻重复元素,记得使⽤STL中的adjacent_find算法3.4binary_search功能描述 :查找指定元素是否存在函数原型:bool binary_search(iterator beg,iterator end,value);查找指定的元素,找到则返回true,否则返回false注意:⽆序序列中不可⽤⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//binary_search()查找指定元素是否存在//必须在有序的序列中void test01(){vector<int>v;for (int i = 0; i < 10; i++){v.push_back(i);}//容器必须是有序序列bool ret = binary_search(v.begin(), v.end(), 9);if (ret){cout << "找到了" << endl;}else{cout << "没有找到" << endl;}}int main(){test01();system("pause");return 0;}running找到了3.5count功能描述:统计元素个数函数原型:count(iterator beg,iterator end,value);** 统计元素出现的次数⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//count//统计内置数据类型void test01(){vector<int>v;v.push_back(10);v.push_back(20);v.push_back(30);v.push_back(20);v.push_back(10);v.push_back(20);int num = count(v.begin(), v.end(), 20);cout << "20的个数:" << num << endl;}//统计⾃定义数据类型class Person{public:Person(string name, int age){this->m_name = name;this->m_age = age;}//重载==运算符bool operator==(const Person& p)//const必须要加{if (this->m_age == p.m_age){return true;}else{return false;}}string m_name;int m_age;};void test02(){vector<Person>v2;Person p1("孙悟空", 10);Person p2("猪⼋戒", 30);Person p3("沙和尚", 30);Person p4("红孩⼉", 30);v2.push_back(p1);v2.push_back(p2);v2.push_back(p3);v2.push_back(p4);Person p("唐僧", 30);int num2 = count(v2.begin(), v2.end(), p);//统计和唐僧年龄相同的⼈的个数 cout << "和唐僧年龄相同的⼈员个数为:" << num2 << endl;}int main(){test01();test02();system("pause");return 0;}```**running**3.6count_if功能描述:按条件统计元素个数函数原型:count_if(iterator bed,iterator end,_Pred);按条件统计元素出现次数_Pred谓词⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>//count_if//统计内置数据类型class Greater20{public:bool operator()(int val){return val > 20;}};void test01(){vector<int>v;v.push_back(10);v.push_back(20);v.push_back(30);v.push_back(40);v.push_back(50);v.push_back(70);int num = count_if(v.begin(), v.end(), Greater20());//Greater20()仿函数 cout << "⼤于20的个数:" << num << endl;}//统计⾃定义数据类型class Person{public:Person(string name, int age){this->m_name = name;this->m_age = age;}//重载==运算符bool operator>(const Person& p){if (this->m_age > p.m_age){return true;}else{return false;}}string m_name;int m_age;};class AgeGreater20{public:bool operator()(const Person& p1){return p1.m_age > 20;}};void test02(){vector<Person>v2;Person p1("孙悟空", 10);Person p2("猪⼋戒", 30);Person p3("沙和尚", 30);Person p4("红孩⼉", 30);v2.push_back(p1);v2.push_back(p2);v2.push_back(p3);v2.push_back(p4);Person p("唐僧", 30);int num2 = count_if(v2.begin(), v2.end(),AgeGreater20());cout << "年龄⼤于20的⼈员个数为:" << num2 << endl;}int main(){test01();test02();system("pause");return 0;}running⼤于20的个数:4年龄⼤于20的⼈员个数为:320的个数:3和唐僧年龄相同的⼈员个数为:34.常⽤的排序算法算法简介:sort对容器内元素进⾏升序random_shuffle洗牌指定范围内的元素随即调整次序merge容器元素合并,并存储到另⼀容器中reverse反转指定范围的元素4.1sort功能描述:对容器内元素进⾏排序函数原型:sort(iterator beg,iterator end,_Pred);按值查找元素,找到返回指定元素迭代器,找不到返回结束位置迭代器_Pred 谓词⽰例:#include<iostream>using namespace std;#include<vector>#include<algorithm>#include<functional>//sortvoid MyPrint(int val){cout << val << " ";}void test01(){vector<int>v;v.push_back(3);v.push_back(1);v.push_back(4);v.push_back(5);v.push_back(2);sort(v.begin(), v.end());for_each(v.begin(), v.end(),MyPrint);cout << endl;//改为降序sort(v.begin(), v.end(), greater<int>());for_each(v.begin(), v.end(), MyPrint);cout << endl;}int main(){test01();system("pause");return 0;}running1 2 3 4 55 4 3 2 14.2random_shuffle功能:指定范围内的元素随即调整次序函数原型:random_shuffle(iterator beg,iterator end);#include<iostream>using namespace std;#include<vector>#include<algorithm>void Myprint(int val){cout << val << " ";}void test01(){vector<int>v;for (int i = 0; i < 10; i++){v.push_back(i);}random_shuffle(v.begin(), v.end());for_each(v.begin(), v.end(),Myprint);}int main(){test01();system("pause");return 0;}4.3merge功能描述:两个容器元素合并,并存储到令⼀容器中函数原型:merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);两个容器必须是有序的。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

STL常用总结Last Update (July. 2014) by WINGACM/ICPC 竞赛之STL 简介一、关于STLSTL(Standard Template Library,标准模板库)是C++语言标准中的重要组成部分。

STL 以模板类和模板函数的形式为程序员提供了各种数据结构和算法的精巧实现,程序员如果能够充分地利用STL,可以在代码空间、执行时间和编码效率上获得极大的好处。

STL 大致可以分为三大类:算法(algorithm)、容器(container)、迭代器(iterator)。

STL 容器是一些模板类,提供了多种组织数据的常用方法,例如vector(向量,类似于数组)、list(列表,类似于链表)、deque(双向队列)、set(集合)、map(映象)、stack(栈)、queue(队列)、priority_queue(优先队列)等,通过模板的参数我们可以指定容器中的元素类型。

STL 算法是一些模板函数,提供了相当多的有用算法和操作,从简单如for_each(遍历)到复杂如stable_sort(稳定排序)。

STL 迭代器是对C 中的指针的一般化,用来将算法和容器联系起来。

几乎所有的STL 算法都是通过迭代器来存取元素序列进行工作的,而STL 中的每一个容器也都定义了其本身所专有的迭代器,用以存取容器中的元素。

有趣的是,普通的指针也可以像迭代器一样工作。

熟悉了STL 后,你会发现,很多功能只需要用短短的几行就可以实现了。

通过STL,我们可以构造出优雅而且高效的代码,甚至比你自己手工实现的代码效果还要好。

STL 的另外一个特点是,它是以源码方式免费提供的,程序员不仅可以自由地使用这些代码,也可以学习其源码,甚至按照自己的需要去修改它。

下面是用STL 写的题Ugly Numbers 的代码:#include <iostream>#include <queue>using namespace std;typedef pair<unsigned long, int> node_type;int main(){unsigned long result[1500];priority_queue< node_type, vector<node_type>, greater<node_type> >Q;Q.push( make_pair(1, 2) );for (int i=0; i<1500; i++){node_type node = Q.top(); Q.pop();switch(node.second){case 2: Q.push( make_pair(node.first*2, 2) );case 3: Q.push( make_pair(node.first*3, 3) );case 5: Q.push( make_pair(node.first*5, 5) );}result[i] = node.first;}int n;cin >> n;while (n>0){cout << result[n-1] << endl;cin >> n;}return 0;}在ACM 竞赛中,熟练掌握和运用STL 对快速编写实现代码会有极大的帮助。

二、使用STL在C++标准中,STL 被组织为以下的一组头文件(注意,是没有.h 后缀的!):algorithm / deque / functional / iterator / list / mapmemory / numeric / queue / set / stack / utility / vector当我们需要使用STL 的某个功能时,需要嵌入相应的头文件。

但要注意的是,在C++标准中,STL 是被定义在std 命名空间中的。

如下例所示:#include <stack>int main(){std::stack<int> s;s.push(0);...return 0;}如果希望在程序中直接引用STL,也可以在嵌入头文件后,用using namespace 语句将std 命名空间导入。

如下例所示:#include <stack>using namespace std;int main(){stack<int> s;s.push(0);...return 0;}STL 是C++语言机制运用的一个典范,通过学习STL 可以更深刻地理解C++ 语言的思想和方法。

在本系列的文章中不打算对STL 做深入的剖析,而只是想介绍一些STL 的基本应用。

有兴趣的同学,建议可以在有了一些STL 的使用经验后,认真阅读一下《C++ STL》这本书(电力出版社有该书的中文版)。

ACM/ICPC 竞赛之STL--pairSTL 的<utility>头文件中描述了一个看上去非常简单的模板类pair,用来表示一个二元组或元素对,并提供了按照字典序对元素对进行大小比较的比较运算符模板函数。

例如,想要定义一个对象表示一个平面坐标点,则可以:pair<double, double> p1;cin >> p1.first >> p1.second;pair 模板类需要两个参数:首元素的数据类型和尾元素的数据类型。

pair 模板类对象有两个成员:first 和second,分别表示首元素和尾元素。

在<utility>中已经定义了pair 上的六个比较运算符:<、>、<=、>=、==、!=,其规则是先比较first,first 相等时再比较second,这符合大多数应用的逻辑。

当然,也可以通过重载这几个运算符来重新指定自己的比较逻辑。

除了直接定义一个pair 对象外,如果需要即时生成一个pair 对象,也可以调用在<utility>中定义的一个模板函数:make_pair。

make_pair 需要两个参数,分别为元素对的首元素和尾元素。

在题1067--Ugly Numbers 中,就可以用pair 来表示推演树上的结点,用first 表示结点的值,用second 表示结点是由父结点乘以哪一个因子得到的。

#include <iostream>#include <queue>using namespace std;typedef pair<unsigned long, int> node_type;int main(){unsigned long result[1500];priority_queue< node_type, vector<node_type>, greater<node_type>> Q;Q.push( make_pair(1, 2) );for (int i=0; i<1500; i++){node_type node = Q.top(); Q.pop();switch(node.second){case 2: Q.push( make_pair(node.first*2, 2) );case 3: Q.push( make_pair(node.first*3, 3) );case 5: Q.push( make_pair(node.first*5, 5) );}result[i] = node.first;}int n;cin >> n;while (n>0){cout << result[n-1] << endl;cin >> n;}return 0;}<utility>看上去是很简单的一个头文件,但是<utility>的设计中却浓缩反映了STL 设计的基本思想。

有意深入了解和研究STL 的同学,仔细阅读和体会这个简单的头文件,不失为一种入门的途径。

ACM/ICPC 竞赛之STL--vector在STL 的<vector>头文件中定义了vector(向量容器模板类),vector 容器以连续数组的方式存储元素序列,可以将vector 看作是以顺序结构实现的线性表。

当我们在程序中需要使用动态数组时,vector 将会是理想的选择,vector 可以在使用过程中动态地增长存储空间。

vector 模板类需要两个模板参数,第一个参数是存储元素的数据类型,第二个参数是存储分配器的类型,其中第二个参数是可选的,如果不给出第二个参数,将使用默认的分配器。

下面给出几个常用的定义vector 向量对象的方法示例:vector<int> s;定义一个空的vector 对象,存储的是int 类型的元素。

vector<int> s(n);定义一个含有n 个int 元素的vector 对象。

vector<int> s(first, last);定义一个vector 对象,并从由迭代器first 和last 定义的序列[first, last)中复制初值。

vector 的基本操作有:s[i]直接以下标方式访问容器中的元素。

s.front()返回首元素。

s.back()返回尾元素。

s.push_back(x)向表尾插入元素x。

s.size()返回表长。

s.empty()当表空时,返回真,否则返回假。

s.pop_back()删除表尾元素。

s.begin()返回指向首元素的随机存取迭代器。

s.end()返回指向尾元素的下一个位置的随机存取迭代器。

s.insert(it, val)向迭代器it 指向的元素前插入新元素val。

s.insert(it, n, x)向迭代器it 指向的元素前插入n 个x。

s.insert(it, first, last)将由迭代器first 和last 所指定的序列[first, last)插入到迭代器it 指向的元素前面。

s.erase(it)删除由迭代器it 所指向的元素。

s.erase(first, last)删除由迭代器first 和last 所指定的序列[first, last)。

s.reserve(n)预分配缓冲空间,使存储空间至少可容纳n 个元素。

s.resize(n)改变序列的长度,超出的元素将会被删除,如果序列需要扩展(原空间小于n),元素默认值将填满扩展出的空间。

s.resize(n, val)改变序列的长度,超出的元素将会被删除,如果序列需要扩展(原空间小于n),将用val 填满扩展出的空间。

相关文档
最新文档