首页 > 编程语言> 文章详细

C++STL标准库学习笔记（十三）算法（上）

2022-02-01 17:00:21 阅读：152 来源： 互联网

标签：last iterator STL init C++ ostream 算法区间 first

前言：

　　在这个笔记中，我把大多数代码都加了注释，我的一些想法和注解用蓝色字体标记了出来，重点和需要关注的地方用红色字体标记了出来。

　　在这一篇文章中，我们主要对STL中的算法进行简单的介绍。

正文：

1. STL算法分类

　　STL中的算法大致可以分为以下七类：

　　不变序列算法

　　变值算法

　　删除算法

　　变序算法

　　排序算法

　　有序区间算法

　　数值算法

2. STL算法

　　大多数重载算法都是有两个版本的

　　　　用“==”判断元素是否相等，或用“<”来比较大小

　　　　多出一个类型参数“pred”和函数形参“pred op”：

　　　　通过判断表达式“op(x,y)”的返回值：true/false

　　来判断x是否“等于”y，或者x是否“小于”y

　　如有下列两个版本的min_element：
　　iterator min_element(iterator first, iterator last);

　　iterator min_element(iterator first, iterator last, Pred op);

　　（其实不就是多了一个要传入的比较规则嘛）

2.1. 不变序列算法

　　该类算法不会修改算法所作用的容器或对象

　　适用于顺序容器和关联容器

　　时间复杂度都是O(n)

　　min：求两个对象中较小的（可自定义比较器）

　　max：求两个对象中较大的（可自定义比较器）

　　min_element：求区间中的最小值（可自定义比较器）

　　max_element：求区间中的最大值（可自定义比较器）

　　for_each：对区间中的每个元素都做某种操作

　　count：计算区间中等于某值的元素个数

　　count_if：计算区间中符合某种条件的元素个数

　　find：在区间中查找等于某值的元素

　　find_if：在区间中查找符合某条件的元素

　　find_end：在区间中查找另一个区间最后一次出现的位置（可自定义比较器）

　　find_first_of：在区间中查找第一个出现在另一个区间中的元素（可自定义比较器）

　　adjacent_find：在区间中寻找第一次出现连续两个相等元素的位置（可自定义比较器）

　　search：在区间中查找另一个区间第一次出现的位置（可自定义比较器）

　　search_n：在区间中查找第一次出现等于某值的连续n个元素（可自定义比较器）

　　equal：判断两区间是否相等（可自定义比较器）

　　mismatch：逐个比较两个区间的元素，返回第一次发生不相等的两个元素的位置（可自定义比较器）

　　lexicographical_compare：按字典序比较两个区间的大小（可自定义比较器）

　　find:

　　template<class init, class T>

　　init find(init first, init last, const T& val);

　　返回[first,last)中的迭代器i，使得*i==val

　　find_if:

　　templast<class init, class Pred>

　　init find_if(init first, init last, pred pr);

　　返回区间[first, last)中的迭代器i，使得pr(*i)==true

　　（所以说传进来的pr是个函数？查了一下，传入的是一个一元谓词，即只带一个参数且返回值限定为bool的函数对象）

　　for_each:

　　template<class init, class Fun>

　　Fun for_each(init first, init last, Fun f);

　　对[first, last)中的每个元素e，执行f(e)，要求f(e)不能改变e

　　count:

　　template<class init, class T>

　　size_t count(init first, init last, const T& val);

　　计算[first, last)中等于val的元素个数（x==y为true算等于）

　　count_if:

　　template<class init, class Pred>

　　size_t count_if(init first, init last, Pred pr);

　　计算[first, last)中符合pr(e)==true的元素e的个数

　　（用法感觉和find_if差不多）

　　min_element:

　　template<class Fwdlt>

　　Fwdlt min_element(Fwdlt first, Fwdlt last);

　　返回[first, last)中最小元素的迭代器，以“<”作比较器

　　最小指没有元素比它小，而不是它比别的不同元素都小

　　因为即使a!=b，a<b和b<a有可能都不成立

　　max_element:

　　template<class Fwdlt>

　　Fwdlt max_element(Fwdlt first, Fwdlt last);

　　返回[first, last)中最大元素（不小于任何其他元素）的迭代器

　　也是以“<”作比较器

　　样例：

 1 #include<iostream>
 2 #include<algorithm>
 3 using namespace std;
 4 class A
 5 {
 6 public:
 7     int n;
 8     A(int i):n(i){}
 9 };
10 bool operator<(const A & a1, const A & a2)
11 {
12     cout<<"< called"<<endl;
13     if (a1.n==3&&a2.n==7)
14     {
15         return true;
16     }
17     return false;
18 }
19 int main(int argc, char const *argv[])
20 {
21     A aa[] = {3,5,7,2,1};
22     cout<<min_element(aa,aa+5)->n<<endl;
23     cout<<max_element(aa,aa+5)->n<<endl;
24     return 0;
25 }
26 /*
27 输出：
28 < called
29 < called
30 < called
31 < called
32 3
33 < called
34 < called
35 < called
36 < called
37 7
38 */

　　（这里假设第一个元素是最小值，然后逐个比较，发现第一个在定义的“<”下真是最小值，结果就是3，第二种情况就是发现3<7，结果就是7）

2.2. 变值算法

　　此类算法会修改源区间或目标区间元素的值

　　值被修改的那个区间，不可以是属于关联容器的（因为若修改了的话，关联容器的有序性就被打破了）

　　for_each：对区间中的每个元素都做某种操作（与前面的不同就是传入的函数参数是不是const的）

　　copy：复制一个区间到别处

　　copy_backward：复制一个区间到别处，但目标区间是从后往前被修改的

　　transform：将一个区间的元素变形后拷贝到另一个区间

　　swap_ranges：交换两个区间内容

　　fill：用某个值填充区间

　　fill_n：用某个值替换区间中的n个元素

　　generate：用某个操作的结果填充区间

　　generate_n：用某个操作的结果替换区间中的n个元素

　　replace：将区间中的某个值替换成另一个值

　　replace_if：将区间中符合某种条件的值替换成另一个值

　　replace_copy：将一个区间拷贝到另一个区间，拷贝时某个值要换成新值拷过去

　　replace_copy_if：将一个区间拷贝到另一个区间，拷贝时符合某条件的值要换成新值拷过去

transform:

　　template<class init, class Outit, class Unop>

　　Outit transform(init first, init last, outit x, Unop uop);

　　对[first, last)中的每个迭代器l，

　　　　执行uop(*i);并将结果依次放入从x开始的地方

　　　　要求uop(*i)不得改变*i的值

　　本模板返回值是个迭代器，即x+(last-first)

　　　　x可以和first相等

　　样例：（包含了前面和没说的一些东西）

 1 #include<vector>
 2 #include<iostream>
 3 #include<numeric>
 4 #include<list>
 5 #include<algorithm>
 6 #include<iterator>
 7 using namespace std;
 8 class CLessThen9
 9 {
10 public:
11     bool operator()(int n){return n < 9;}
12 };
13 void outputSquare(int value){cout<<value*value<<" ";}
14 int calculateCube(int value){return value*value*value;}
15 
16 int main(int argc, char const *argv[])
17 {
18     const int SIZE = 10;
19     int a1[] = {1,2,3,4,5,6,7,8,9,10};
20     int a2[] = {100,2,8,1,50,3,8,9,10,2};
21     vector<int> v(a1,a1+SIZE);
22     ostream_iterator<int> output(cout," ");
23     random_shuffle(v.begin(),v.end());//随机打乱区间的值
24     cout<<endl<<"1)";//输出：1)9 2 10 3 1 6 8 4 5 7（这里是随机的）
25     copy(v.begin(),v.end(),output);
26     copy(a2,a2+SIZE,v.begin());
27     cout<<endl<<"2)";//输出：2)2
28     cout<<count(v.begin(),v.end(),8);
29     cout<<endl<<"3)";//输出：3)6
30     cout<<count_if(v.begin(),v.end(),CLessThen9());//这里就调用了对象
31     cout<<endl<<"4)";//输出：4)1
32     cout<<*(min_element(v.begin(),v.end()));
33     cout<<endl<<"5)";//输出：5)100
34     cout<<*(max_element(v.begin(),v.end()));
35     cout<<endl<<"6)";//输出：6)193
36     cout<<accumulate(v.begin(),v.end(),0);//求和，累加到0上面
37     cout<<endl<<"7)";//输出：10000 4 64 1 2500 9 64 81 100 4
38     for_each(v.begin(),v.end(),outputSquare);
39     vector<int> cubes(SIZE);
40     transform(a1,a1+SIZE,cubes.begin(),calculateCube);//a1的立方放到了cubes里面
41     cout<<endl<<"8)";//输出：1 8 27 64 125 216 343 512 729 1000
42     copy(cubes.begin(),cubes.end(),output);
43     
44     return 0;
45 }

　　其中：

　　ostream_iterator<int> output(cout," ");

　　定义了一个ostream_iterator<int>对象，可以通过cout输出以“ ”（空格）分割的一个个整数

　　copy(v.begin(),v.end(),output);

　　导致v的内容在cout上输出

　　（老师讲到这里的时候放起了慷慨激昂的音乐）

　　copy:

　　template<class init, class outit>

　　outit copy(init first, init last, outit x);

　　本函数对每个在区间[0,last-first)中的N执行一次*(x+N) = *(first+N)，返回x+N

　　对于copy(v.begin(),v.end(),output);

　　first和last的类型是vector<int>::const_iterator

　　output的类型是ostream_iterator<int>

　　copy的源码

1 template<class _ll, class _ol>
2 inline _ol copy(_ll _F,_ll _L,_ol _X)
3 {
4     for (;_F != _L; ++_X,++_F)
5         *_X = *_F;
6     return(_X);
7 }

　　一个问题，在下面的程序中如何编写My_ostream_iterator？

 1 #include<iostream>
 2 #include<fstream>
 3 #include<string>
 4 #include<algorithm>
 5 #include<iterator>
 6 using namespace std;
 7 int main(int argc, char const *argv[])
 8 {
 9     int a[4] = {1,2,3,4};
10     My_ostream_iterator<int> oit(cout,"*");
11     copy(a,a+4,oit);//输出 1*2*3*4*
12     ofstream oFile("test.txt",ios::out);
13     My_ostream_iterator<int> oitf(oFile,"*");
14     copy(a,a+4,oitf);//向text.txt文件中写入1*2*3*4
15     oFile.close();
16     return 0;
17 }//如何编写My_ostream_iterator？？？

　　在上面程序中调用“copy(a,a+4,oit)”实例化后得到copy如下：

1 template<class _ll, class _ol>
2 inline My_ostream_iterator<int> copy(int _F,int _L,My_ostream_iterator<int> _X)
3 {
4     for (;_F != _L; ++_X,++_F)
5         *_X = *_F;
6     return(_X);
7 }

　　My_ostream_iterator类应该重载“++”和“*”运算符

　　“=”也应该被重载

 1 #include<iterator>
 2 #include<iostream>
 3 #include<string>
 4 template<class T>
 5 class My_ostream_iterator:public iterator<output_iterator_tag, T>
 6 {
 7     private:
 8     string sep;//分隔符
 9     ostream & os;
10     public:
11     My_ostream_iterator(ostream & o,string s):sep(s),os(o){}
12     void operator++(){};//++只需要有定义即可，不需要做什么
13     My_ostream_iterator & operator*(){return *this;}
14     My_ostream_iterator & operator=(const T & val)
15     { os<<val<<sep;return *this;}
16 };

（io流给我整晕了555）

后记：

　　这节课好长啊，下次看见这么长的课，我就。。。。乖乖看完，总不能不学对不对，不说了，各位新年快乐，祝各位码运昌隆！

标签：last,iterator,STL,init,C++,ostream,算法,区间,first
来源： https://www.cnblogs.com/AwakeFantasy/p/15859234.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

C++STL标准库学习笔记（十三）算法（上）

前言：