精华内容
参与话题
问答
  • algorithm头文件常用函数

    千次阅读 多人点赞 2019-01-10 19:23:43
    algorithm意为"算法",是C++的标准模版库(STL)中最重要的头文件之一,提供了大量基于迭代器的非成员模板函数。 类 别 C++标准库 头文件 #include <algorithm> 命名...

    algorithm意为"算法",是C++的标准模版库(STL)中最重要的头文件之一,提供了大量基于迭代器的非成员模板函数。

    • 类 别 C++标准库
    • 头文件 #include <algorithm>
    • 命名空间 using namespace std

    其中包括以下部分函数:

    1. max()、min()和abs()
    2. swap()
    3. reverse()
    4. next_permutation()
    5. fill()
    6. sort()
    7. lower_bound()和upper_bound()
    • 最大最小操作
    max 返回两个元素中值最大的元素
    min 返回两个元素中值最小的元素
    abs() 返回元素绝对值
    next_permutation 返回给定范围中的元素组成的下一个按字典序的排列
    • 修改内容操作
    swap 交换两个对象的值
    reverse 反转排序指定范围中的元素
    fill 将一个范围的元素赋值为给定值
    • 排序操作
    sort 排序
    • 查找操作
    lower_bound 返回指向范围中第一个值大于或等于给定值的元素的迭代器
    upper_bound 返回指向范围中第一个值大于给定值的元素的迭代器
    • max()

    作 用:返回一个最大数值
    语 法:MAX(number1,number2,…)
    参 数: Number1,number2,

    注意: 如果参数不包含数字,函数 MAX 返回 0。

    示例
    示例1:如果 A1:A5 包含数字 10、7、9、27 和 2,则:
    MAX(A1:A5) 等于 27
    MAX(A1:A5,30) 等于 30

    示例2:如果A1=71、A2=83、A3=76、A4=49、A5=92、A6=88、A7=96。
    则公式“=MAX(A1:A7)”返回96。

    #include <iostream>    
    #include <algorithm>    
    using namespace std;
    int main () {
      cout << "max(1,2)==" << std::max(1,2) << '\n';
      cout << "max(2,1)==" << std::max(2,1) << '\n';
      cout << "max('a','z')==" << std::max('a','z') << '\n';
      cout << "max(3.14,2.73)==" << std::max(3.14,2.73) << '\n';
      return 0;
    }
    

    在这里插入图片描述

    • min()

    min(x,y)分别返回x和y中的最小值,且参数必须是两个。

    示例1:如果 A1:A5 中依次包含数值 10,7,3,27 和 2,那么
    MIN(A1:A5) 等于 2
    MIN(A1:A5, 0) 等于 0

    例:

    #include <iostream>     
    #include <algorithm>    
    using namespace std;
    int main () {
      cout << "min(1,2)==" << min(1,2) << '\n';
      cout << "min(2,1)==" << min(2,1) << '\n';
      cout << "min('a','z')==" << min('a','z') << '\n';
      cout << "min(3.14,2.72)==" << min(3.14,2.72) << '\n';
      return 0;
    }
    

    在这里插入图片描述

    • abs()

    abs(x) 返回x的绝对值。x必须为整数,浮点型的绝对值要用math头文件下的fabs

    //#include<algorithm>
    #include<cstdio>
    #include<cmath>
    #include<iostream>
    using namespace std;
    int main()
    {
        int x,f;
     
    	printf("请输入一个整数:\n");
    	scanf("%d",&x);
    	printf("绝对值为%d\n",abs(x));
    
    //	printf("请输入一个浮点数:\n");
    //	scanf("%lf",&f);
    //	printf("绝对值为%lf\n",fabs(f));
    	return 0;
    }
    
    

    如果没有头文件,绝对值返回0
    在这里插入图片描述

    • swap()
      交换两个对象的值,即交换a和b的值。

    通用的函数交换模板
    template<class T> void swap(T &a,T &b) { T c(a); a=b; b=c; }
    针对int类型的优化

    void swap(int &a,int &b)
     {
         a^=b;
         b^=a;       //相当于b=a
        a^=b;       //相当于a=b
     }
    

    自定义swap时,注意事项
    1.无法实现交换目的

    void swap(int a,int b)//这里只是交换了a和b实参的副本,而它们本身没有交换。
     {
         int temp=a;
        a=b;
       b=temp;
     }
    

    2.能够达到交换目的

    #include <iostream>    
    #include <algorithm>   
     
    using namespace std;
    void swap(int *a,int *b)
    {
        int temp;
        temp=*a;
        *a=*b;
        *b=temp;
    }
    
    //使用
    int main()
    {
        int a=1,b=2;
        swap(&a,&b);
      cout<<a<<endl;
      cout<<=<<endl;
        return 0;
    }
    

    在这里插入图片描述

    • reverse()

    1.会将区间内的元素全部逆序。常用于数组,字符串,容器等,其本身的函数参数也不复杂。
    2.容器类型的要用begin()和end()来指定反转的区域,数组类型的直接用int类型即可。
    3.reverse函数用于反转在[first,last)范围内的顺序(包括first指向的元素,不包括last指向的元素),reverse函数没有返回值

    此函数模板的行为等效于(通过调用iter_swap来交换元素位置):

    template <class BidirectionalIterator>
      void reverse (BidirectionalIterator first, BidirectionalIterator last)
    {
      while ((first!=last)&&(first!=--last)) {
        std::iter_swap (first,last);
        ++first;
      }
    }
    
    • 交换vector容器中元素的顺序
    vector<int> v = {5,4,3,2,1};
    reverse(v.begin(),v.end());//v的值为1,2,3,4,5
    
    • string类的字符串
    string str="www.mathor.top";
    reverse(str.begin(),str.end());//str结果为pot.rohtam.wwww
    

    #include<stdio.h>
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
    	int a[50];
    	int b[50]; 
    	for(int i=0;i<10;i++)
    	{
    		a[i]=i;
    		if(i!=9)
    		cout<<a[i]<<" ";
    		else
    		cout<<a[i]<<endl;
    	}
    	reverse(a,a+10);         //第二个参数是数组最后一个元素的下一个地址 
    	for(int i=0;i<10;i++)
    	{
    		if(i!=9)
    		cout<<a[i]<<" ";
    		else
    		cout<<a[i]<<endl;
    	}
    }
    
    

    在这里插入图片描述

    • next_permutation()

    返回给定范围中的元素组成的下一个按字典序的排列,next_permutation(start,end)和prev_permutation(start,end)。这两个函数作用是一样的,区别就在于前者求的是当前排列的下一个排列,后一个求的是当前排列的上一个排列。

    next_permutation函数,其函数原型为:

       #include <algorithm>
    
         bool next_permutation(iterator start,iterator end)//当当前序列不存在下一个排列时,函数返回false,否则返回true
    
    • 当把while(next_permutation(num,num+3))中的3改为2时,输出就变为了:只对1,2进行全排,可以知道next_permutation(num,num+n)函数是对数组num中的前n个元素进行全排列,同时并改变num数组的值。
      在这里插入图片描述
    • 还有next_permutation()在使用前需要对欲排列数组按升序排序,否则只能找出该序列之后的全排列数。比如,如果数组num初始化为2,3,1,那么输出就变为了:
      在这里插入图片描述
    • 此外,next_permutation(node,node+n,cmp)可以对结构体num按照自定义的排序方式cmp进行排序。也可以对字符next_permutation 自定义比较函数

    • 若排列本米就是最大的了没有后继,则next permotation执行后,会对
      排列进行字典开序排序相当于循环
    int list[31={3.,2.1};
    next permutation(list,list+3);
    conut<<list[0]<<" "<list[U<<" "<listl2k<<endl;//输出:1 2 3
    
    
    • List item

    char类型的next permutation

    //
    该语句对输入的数组进行字典升序排序如输入9874563102 cout<<ch;
    将输出 0123456789这样就能输出全排列了
    
    int mainO
    char ch[2051;cin>> ch;
    sort(ch, ch+ strlen(ch));
    
    //这样就不必事先知道ch的大小了,是把整个ch字符串全都进行排序
    //若采用while(nextpermutation(ch,ch+5);如果只输入1562,就会产
    生错误,因为ch中第五个元素指向未知
    //若要整个字符中进行排序,参数5指的是数组的长度,不含结束符
    
    char *frstE ch;
    char *last ch+ strlen(ch);
    do{
    cout<<ch<< endl;
    }while(next permutation(first,lastD);return0;
    
    • string类型的nextpermutation
    int main()
    {
    	string line;
    	while(cin>>line&&line!="#"')
    	{
    		if(nexL permutation(line.beginQline.end0)当前输入位置开始
    		cout<line<<endl;
    		elsecout<< "Nosuccesor\";
    	}
    }
    
    int main()
    {
    	string line;
    	while(cin> >line&line!= "#")
    	{
    		sort(line.begin(),line.end0);/排列cout< dline<<endl;
    	}
    }
    
    
    

        #include <iostream>  
        #include <algorithm>  
        using namespace std;  
        int main()  
        {  
            int num[3]={1,2,3};  
            do  
            {  
                cout<<num[0]<<" "<<num[1]<<" "<<num[2]<<endl;  
            }
            while(next_permutation(num,num+3));  
            return 0;  
        }  
    

    在这里插入图片描述

    • fill()

    1.按照单元赋值,将一个区间的元素都赋同一个值
    2.fill(arr, arr + n, 要填入的内容);
    fill(vector.begin(), vector.end(), val);
    3.

    #include <cstdio>
    #include <algorithm>
    using namespace std;
    int main() {
        int arr[10];
        fill(arr, arr + 10, 2);
        return 0;
    }
    

    4.vector容器

    #include <algorithm>
     #include <vector> 
     #include <iostream> 
     using namespace std; 
     int main()
     { 
    	 vector<int>  v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    	  fill(v.begin(), v.end(), -1);
    	   return 0; 
       } 
    
    

    #include <iostream>
    #include <algorithm>
    #include <vector>
    using namespace std;
    
    int main () {
    	vector<int> myvector (8);// myvector: 0 0 0 0 0 0 0 0
    	fill (myvector.begin(),myvector.begin()+4,5);
    	// myvector: 5 5 5 5 0 0 0 0
    	fill (myvector.begin()+3,myvector.end()-2,8);
    	// myvector: 5 5 5 8 8 8 0 0
    	
    	cout << "myvector contains:";
    	for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    	cout << " " << *it;
    	
    	cout << endl;
    	return 0;
    }
    

    在这里插入图片描述

    • sort()

    1.Sort函数有三个参数:
    (1)第一个是要排序的数组的起始地址。
    (2)第二个是结束的地址(最后一位要排序的地址的下一地址)
    (3)第三个参数是排序的方法,可以是从大到小也可是从小到大,还可以不写第三个参数,此时默认的排序方法是从小到大排序。
    2.Sort函数使用模板:Sort(start,end,排序方法)

    //例一:sort函数没有第三个参数,实现的是从小到大
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
    int a[10]={9,6,3,8,5,2,7,4,1,0};
    	for(int i=0;i<10;i++)
    	cout<<a[i]<<endl;
    	sort(a,a+10);
    	for(int i=0;i<10;i++)
    	cout<<a[i]<<endl;
    	return 0;
    }
    
    //例2需要在sort()函数里的第三个参数里,从大到小排序!
    //加入一个比较函数compare(),
    #include<iostream>
    #include<algorithm>
    using namespace std;
    bool compare(int a,int b)
    {
    return a>b;
    }
    int main()
    {
    int a[10]={9,6,3,8,5,2,7,4,1,0};
    for(int i=0;i<10;i++)
    cout<<a[i]<<endl;
    sort(a,a+10,compare);//在这里就不需要对compare函数传入参数了,
    //这是规则
    for(int i=0;i<10;i++)
    cout<<a[i]<<endl;
    return 0;
    }
    
    
    • lower_bound()和upper_bound( )

    lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。

    、lower_bound()

    • lower_bound()返回值是一个迭代器,返回指向比key大的第一个值的位置
      对象:有序数组或容器
    • lower_bound(起始地址,结束地址,要查找的数值) 返回的是数值 第一个 出现的位置。
    • 功能:函数lower_bound()在first和last中的前闭后开区间进行二分查找,返回大于或等于val的第一个元素位置。如果所有元素都小于val,则返回last的位置.

    注意:如果所有元素都小于val,则返回last的位置,且last的位置是越界的!!

    二、upper_bound()

    • upper_bound(起始地址,结束地址,要查找的数值) 返回的是数值 最后一个 出现的位置。
    • 功能:函数upper_bound()返回的在前闭后开区间查找的关键字的上界,返回大于val的第一个元素位置

    注意:返回查找元素的最后一个可安插位置,也就是“元素值>查找值”的第一个元素的位置。同样,如果val大于数组中全部元素,返回的是last。(注意:数组下标越界)

     #include <iostream>  
        #include <algorithm>  
        #include<vector>
        using namespace std; 
    int main()
    {
        vector<int> t;
        t.push_back(1);
        t.push_back(2);
        t.push_back(3);
        t.push_back(4);
        t.push_back(6);
        t.push_back(7);
        t.push_back(8);
    
        
        int low=lower_bound(t.begin(),t.end(),5)-t.begin();
        int upp=upper_bound(t.begin(),t.end(),5)-t.begin();
        cout<<low<<endl;
        cout<<upp<<endl;
    
        
        
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • algorithm用法详解

    千次阅读 2019-05-07 19:18:39
    algorithm>定义了一系列特别设计用于元素范围的函数。 范围是可以通过迭代器或指针访问的任何对象序列,例如数组或某些STL 容器的实例。但请注意,算法直接通过迭代器对值进行操作,不会以任何方式影响任何可能...

    标准库模板: Algorithms

    头文件<algorithm>定义了一系列特别设计用于元素范围的函数。

    范围是可以通过迭代器或指针访问的任何对象序列,例如数组或某些STL 容器的实例。但请注意,算法直接通过迭代器对值进行操作,不会以任何方式影响任何可能容器的结构(它永远不会影响容器的大小或存储分配)。


    在开始之前,首先介绍下一些模板的知识,本文在介绍具体函数之前,先把函数总览列了出来,如果读者不想看全部内容,可以检索定位到自己喜欢的函数,直接查看。在查看本文章之前需要读者具备一定的 vector 知识。本文作者只写了algorithm 中常用的一些函数,如果读者有其他需要,可以在博客中留言,博主会为读者添加

    vector 参考链接: https://blog.csdn.net/qq_41291253/article/details/89840185 

    函数模板与类模板

    模板是实现代码重用机制的一种工具,它可以实现类型参数化,即把类型定义为参数,从而实现了代码的重用。所谓函数模板,实际上就是建立一个通用函数,其函数返回类型形参类型不具体制定,用一个虚拟的类型来代表。

    函数模板声明格式如下:

    template <typename/class 类型参数>
       返回类型 函数名(模板形参表)
    {
        函数体
    }
    
    //求最大值函数 max()定义成函数模板
    template <typename T>
       T max(T x, T y)
    {   return(x > y) ? x : y;  }
    
    //使用方式,直接函数名调用
    int x1, y1;
    double x2, y2;
    max(x1, y1);
    max(x2, y2);

    类模板

    template <class 类型参数>
    class 类名
    {
        类成员声明
    };
    
    //求三个数之和
    template <class T>
       class Three
    {
        public::
            Three(T a, T b, T c)
            { x = a; y = b; z = c;}
            T sum()
            { return x + y + z;}
        private:
            T x, y, z;
    };
    
    //使用方式,
    类模板名<实际类型名>对象名;
    类模板名<实际对象名>对象名(实参表列);
    Three<int> sum3(3, 5, 7);
    

    函数总览:

    一、非修改序列函数

    1.for_each

    将函数fn应用于[first,last)范围中的每个元素

    2.find

    [first,last)范围内比较元素值是否等于val并返回第一个等于 val元素的迭代器

    3.find_if

    返回在[first,last]范围中的元素传入pred函数中返回true的第一个元素的迭代器

    4.search

    搜索[first1,last1)定义的范围中第一次出现[first2,last2)序列,并将迭代器返回到其第一个元素

    5.find_end

    搜索[first1,last1)定义的范围中最后一次出现[first2,last2)序列,并将迭代器返回到其第一个元素

    6.count

    计算[first, last)范围内等于 val 值的元素数

    7.count_if

    在[first1,last1)范围内返回满足 pred函数条件的元素总数

    8.search_n

    在[first, last)范围内搜索最小连续元素(count)都等于val值的第一个元素的迭代器

    二、修改序列函数

    1.copy 复制范围内的元素
    2.swap 交换两个对象的值

    3.swap_rangs

    交换两个范围的元素
    4.reverse  反向范围
    5.replace 替换范围中的元素
    6.replace_if 根据条件替换范围中的元素
    7.remove 从范围中删除元素
    8.remove_if 根据条件从范围中删除元素
    9.unique 删除范围内的连续重复项

    三、分区

    四、排序

    1.sort 排序范围内的元素
    2.stable_sort 将范围中的元素[first,last)按升序排序,如sort,但stable_sort保留值相等的元素的相对顺序

    五、二进制搜索

    六、合并

    七、堆

    八、最大/最小

    1.max 返回两个值中的最大值(功能模板:int i , j ;  max(i , j);)
    2.min 返回两个值中的最小值

    3.max_element

    返回范围内的最大值
    4.min_element 返回范围内的最小值

    九、其他


    为方便读者检索,可以点击需要查看的函数直接定位

     

    目录

    一、非修改序列函数

    1.for_each:--> 2.find:--> 3.find_if:--> 4.search(-find_end):--> 5.find_end:--> 6.count:--> 7.count_if:--> 8.search_n:

    二、修改序列函数

    1.copy:--> 2.swap:--> 3.swap_rangs--> 4.reverse:--> 5.replace--> 6.replace_if--> 7.remove--> 8.remove_if

    四、排序

    1.sort:--> 2.stable_sort:

    八、最大/最小

    1.max_element / min_element


    函数详解:

    一、非修改序列函数

    1.for_each:

    将函数fn应用于[first,last)范围中的每个元素。

    /*==================================================
    注:fn为一元函数,该函数接受范围内的元素作为参数
        InputIterator Function是参数类型,可变(数组指针,迭代器)
        Function是返回类型,可变。
        for_each 是函数名,不可变
        使用时直接采用函数名+变量的形式进行实例化调用
    ==================================================*/
    template <class InputIterator, class Function>   
       Function for_each (InputIterator first, InputIterator last, Function fn)   
    {
      while (first != last) 
        {
            fn (*first);
            ++first;
        }
      return fn;      // or, since C++11: return move(fn);
    }

    函数用例

    /*==================================================================
     函数操作:for_each()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first,last).
             fn-函数指针或move constructible函数对象
     函数返回:返回 fn
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    void myfunction(int i){
        cout << ' ' << i;
    }
    
    struct myclass{
        void operator()(int i){
            cout << ' ' << i;
        }
    }myobject;
    
    int main()
    {
        vector<int> myvector;
        myvector.push_back(10);
        myvector.push_back(20);
        myvector.push_back(30);
        
        cout << "myvector contains: ";
        for_each(myvector.begin(), myvector.end(), myfunction);  //函数名既是该函数的入口指针
        cout << endl;
        
        cout << "myvector contains: ";
        for_each(myvector.begin(), myvector.end(), myobject);
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains:  10 20 30
             myvector contains:  10 20 30
     =======================================*/

    2.find:

    [first,last)范围内比较元素值是否等于val并返回第一个等于 val元素的迭代器。如果找不到这样的元素,则该函数返回last。

    template<class InputIterator, class T>
      InputIterator find (InputIterator first, InputIterator last, const T& val)
    {
      while (first != last) {
        if (*first == val) return first;
        ++first;
      }
      return last;
    }

    函数用例

    /*==================================================================
     函数操作:find()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first,last).
             val-要在范围内搜索的值
     函数返回:比较等于 val 的范围中第一个元素的 iterator(指针类型/地址),如果没有元素匹配,则函数返回 last.
     注:1.返回查找元素对应角标方法:cout << p - myints.begin();
         因为find 返回值为指针类型,数组为连续存储,所以相减即可返回角标
         2.find 对象为 string 类型。则返回值为 vector<char>::iterator it;类型
            string str = "asfdasfs";     
            vector<char>::iterator it ;
            it = find(helper1.begin(), helper1.end(), str[i]);
            cout << helper2[it - helper1.begin()];
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        //using find with array and pointer
        int myints[] = {10, 20, 30, 40};
        int *p;             //迭代器
        
        p = find(myints, myints + 4, 30);
        if(p != myints + 4)
            cout << "Element found in myints: " << *p << endl;
        else
            cout << "Element not found in myints" << endl;
        
        
        //using find eith vector and iterator
        vector<int> myvector(myints, myints + 4);
        vector<int>::iterator it;
        
        it = find(myvector.begin(), myvector.end(), 50);
        if(it != myvector.end())
            cout << "Element found in myints: " << *it << endl;
        else
            cout << "Element not found in myints" << endl;
        return 0;
    }
    /*=======================================
     函数输出:Element found in myints: 30
             Element not found in myints
     =======================================*/

    3.find_if:

    返回在[first,last]范围中的元素传入pred函数中返回true的第一个元素的迭代器。如果没有找到这样的元素,函数返回last。

    template<class InputIterator, class UnaryPredicate>
      InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
    {
      while (first != last) {
        if (pred(*first)) return first;  //pred 一元函数指针
        ++first;
      }
      return last;
    }

    函数用例

    /*==================================================================
     函数操作:find_if()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first,last).
             pred-一元函数,它接受范围内的一个元素作为参数,并返回一个可转换到bool的值。返回的值指示该元素在此函数的上下文中是否被视为匹配。
             函数不能修改它的参数。
             它可以是函数指针,也可以是函数对象。
     函数返回:pred不返回false的范围内的第一个元素的迭代器。
             如果pred对所有元素都为false,则函数返回last。
     注:一元谓词(unary predicate)接受一个参数的谓词。谓词是一个可调用的表达式,其返回结果是一个能用作条件的值。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool Isodd(int i){
        return ((i % 2) == 1);    //判断是否是奇数
    }
    
    int main()
    {
        //using find with array and pointer
        int myints[] = {10, 25, 30, 45};
        int *p;             //迭代器
        
        p = find_if(myints, myints + 4, Isodd);
        if(p != myints + 4)
            cout << "The first odd value is: " << *p << endl;
        else
            cout << "Element not found in myints" << endl;
        
        //using find eith vector and iterator
        vector<int> myvector;
        myvector.push_back(10);
        myvector.push_back(20);
        vector<int>::iterator it;
        
        it = find_if(myvector.begin(), myvector.end(), Isodd);
        if(it != myvector.end())
            cout << "The fist odd value is: " << *it << endl;
        else
            cout << "Element not found in vector" << endl;
        return 0;
    }
    /*=======================================
     函数输出:The first odd value is: 25
             Element not found in vector
     =======================================*/

    4.search(-find_end):

    搜索[first1,last1)定义的范围中第一次出现[first2,last2)序列,并将迭代器返回到其第一个元素,如果没有找到,则返回last1。

    equality (1)
    template <class ForwardIterator1, class ForwardIterator2>
       ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2);
    
    predicate (2)
    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
       ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                BinaryPredicate pred);
    template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2)
    {
      if (first2 == last2) return first1;  // specified in C++11
      
      while (first1 != last1)
      {
        ForwardIterator1 it1 = first1;
        ForwardIterator2 it2 = first2;
        while (*it1 == *it2) {    // or: while (pred(*it1,*it2)) for version 2
            if (it2 == last2) return first1;
            if (it1 == last1) return last1;
            ++it1; ++it2;
        }
        ++first1;
      }
      return last1;
    }

    函数用例

    /*==================================================================
     函数操作:search()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             将迭代器转发到要搜索的序列的初始和最终位置。使用的范围是[first2,last2).
             pred-二进制函数,接受两个元素作为参数(两个序列中的每一个,按相同的顺序),并返回一个可转换为的值bool。返回值指示在此函数的上下文中是否认为元素匹配。
             该函数不得修改其任何参数。
             这可以是函数指针或函数对象。
     函数返回:一个迭代器,在[first1,last1)的范围内第一次出现[first2,last2)序列的第一个元素。
             如果未找到序列,则函数返回last1。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool mypredicate(int i, int j) { return (i == j); }
    
    int main()
    {
        vector<int> haystack;
        
        //set values:  haystack:10 20 30 40 50 60 70 80 90
        for(int i = 1; i < 10; i++) haystack.push_back(i * 10);
        
        //using default comparrision:
        int needle1[] = {40, 50, 60, 70};
        vector<int>::iterator it;
        it = search(haystack.begin(), haystack.end(), needle1, needle1 + 4);
        
        if(it != haystack.end())
            cout << "needle1 found at position " << it - haystack.begin() << endl;
        else
            cout << "needle1 not dound" << endl;
        
        //using predicate comparison:
        int needle2[] = {20, 30, 50};
        it = search(haystack.begin(), haystack.end(), needle2, needle2 + 3, mypredicate);
        if(it != haystack.end())
            cout << "needle1 found at position " << it - haystack.begin() << endl;
        else
            cout << "needle1 not dound" << endl;
        return 0;
    }
    /*=======================================
     函数输出:needle1 found at position 3
             needle1 not dound
     =======================================*/

    5.find_end:

    搜索[first1,last1)定义的范围中最后一次出现[first2,last2)序列,并将迭代器返回到其第一个元素,如果没有找到,则返回last1。

    equality (1)
    template <class ForwardIterator1, class ForwardIterator2>
       ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,
                                  ForwardIterator2 first2, ForwardIterator2 last2);
    predicate (2)
    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
       ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,
                                  ForwardIterator2 first2, ForwardIterator2 last2,
                                  BinaryPredicate pred);
    
    //注:forwarditerator 前向迭代器
    template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2)
    {
      if (first2 == last2) return last1;  // specified in C++11
    
      ForwardIterator1 ret = last1;
    
      while (first1 != last1)
      {
        ForwardIterator1 it1 = first1;
        ForwardIterator2 it2 = first2;
        while (*it1 == *it2) {    // or: while (pred(*it1, *it2)) for version (2)
            ++it1; ++it2;
            if (it2 == last2) { ret = first1; break; }
            if (it1 == last1) return ret;
        }
        ++first1;
      }
      return ret;
    }

    函数用例

    /*==================================================================
     函数操作:find_end()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             [first2, last2)-待匹配序列
             pred-二元函数,接受两个元素作为参数(两个序列中的每一个,按相同的顺序),并返回一个可转换为的值bool。返回值指示在此函数的上下文中是否认为元素匹配。
             函数不能修改它的参数。
             它可以是函数指针,也可以是函数对象。
     函数返回:一个迭代器,在[first1,last1)中最后出现[first2,last2)序列的第一个元素。
             如果未找到序列,则函数返回last1。
     注:二元谓词(Binary Predicate)接受两个参数的谓词。谓词是一个可调用的表达式,其返回结果是一个能用作条件的值。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool myfunction(int i, int j){
        return (i == j);
    }
    
    int main()
    {
        int myints[] = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
        vector<int> haystack(myints, myints + 10);
        
        int needle1[] = {1, 2, 3};
        
        vector<int>::iterator it;
        it = find_end(haystack.begin(), haystack.end(), needle1, needle1 + 3);
        
        if(it != haystack.end())
            cout << "needle1 last found at position: " << it - haystack.begin() << endl;
        
        int needle2[] = {4, 5, 1};
        it = find_end(haystack.begin(), haystack.end(), needle2, needle2 + 3, myfunction);
        
        if(it != haystack.end())
            cout << "needle1 last found at position: " << it - haystack.begin() << endl;
        
        return 0;
    }
    /*=======================================
     函数输出:needle1 last found at position: 5
             needle1 last found at position: 3
     =======================================*/
    

    6.count:

    计算[first, last)范围内等于 val 值的元素数。

    template <class InputIterator, class T>
      typename iterator_traits<InputIterator>::difference_type
        count (InputIterator first, InputIterator last, const T& val)
    {
      typename iterator_traits<InputIterator>::difference_type ret = 0;
      while (first != last) {
        if (*first == val) ++ret;
        ++first;
      }
      return ret;
    }

    函数用例

    /*==================================================================
     函数操作:count()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             val-需要匹配的值
     函数返回:在[first1,last1)范围内等于 val 的元素数
             返回类型(iterator_traits <InputIterator> :: difference_type)是有符号整数类型。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool myfunction(int i, int j){
        return (i == j);
    }
    
    int main()
    {
        int myints[] = {10, 20, 30, 30, 20, 10, 10, 20};
        long mycount = count(myints, myints + 8, 10);
        cout << "10 appears " << mycount << "times." << endl;
        
        vector<int> myvector(myints, myints + 8);
        mycount = count(myvector.begin(), myvector.end(), 20);
        cout << "20 appears " << mycount << "times." << endl;
        return 0;
    }
    /*=======================================
     函数输出:10 appears 3times.
             20 appears 3times.
     =======================================*/

    7.count_if:

    在[first1,last1)范围内返回满足 pred函数条件的元素数

    template <class InputIterator, class UnaryPredicate>
      typename iterator_traits<InputIterator>::difference_type
        count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
    {
      typename iterator_traits<InputIterator>::difference_type ret = 0;
      while (first != last) {
        if (pred(*first)) ++ret;
        ++first;
      }
      return ret;
    }

    函数用例

    /*==================================================================
     函数操作:count_if()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             pred-一元函数接受范围内的元素作为参数,并返回可转换为bool的值。若返回值为真则此元素参与计数,否则舍弃。
     函数返回:在[first1,last1)范围内pred 不返回 FALSE的元素数
             返回类型(iterator_traits <InputIterator> :: difference_type)是有符号整数类型。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool Isodd(int i) { return ((i % 2) == 1); }
    
    int main()
    {
        vector<int> myvetor;
        for(int i = 1; i < 10; i++) myvetor.push_back(i);
        
        long mycount = count_if(myvetor.begin(), myvetor.end(), Isodd);
        cout << "myvector contatins " << mycount << " odd value." <<endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contatins 5 odd value.
     =======================================*/

    8.search_n:

    在[first, last)范围内搜索最小连续元素(count)都等于val值的第一个元素的迭代器。

    equality (1)

    (-count)

    template <class ForwardIterator, class Size, class T>
       ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                                 Size count, const T& val);
    

    predicate (2)

    (-cont_if)

    template <class ForwardIterator, class Size, class T, class BinaryPredicate>
       ForwardIterator search_n ( ForwardIterator first, ForwardIterator last,
                                  Size count, const T& val, BinaryPredicate pred );
    template<class ForwardIterator, class Size, class T>
      ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                                Size count, const T& val)
    {
      ForwardIterator it, limit;
      Size i;
    
      limit=first; std::advance(limit,std::distance(first,last)-count);
    
      while (first!=limit)
      {
        it = first; i=0;
        while (*it==val)       // or: while (pred(*it,val)) for the pred version
          { ++it; if (++i==count) return first; }
        ++first;
      }
      return last;
    }

    函数用例

    /*==================================================================
     函数操作:search_n()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             将迭代器转发到要搜索的序列的初始和最终位置。使用的范围是[first2,last2).
             count-要匹配的最小连续元素数(int 类型)
             val-要比较的单个值,或作为 pred的参数
             pred-二进制函数,接受两个元素作为参数(序列中的一个元素作为一个,val 作为第二个),并返回一个可转换为的值bool。返回值指示在此函数的上下文中是否认为元素匹配。
             该函数不得修改其任何参数。
             这可以是函数指针或函数对象。
     函数返回:一个迭代器,匹配序列的第一个元素
             如果没有找到这样的序列,则返回 last
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool mypredicate(int i, int j) { return (i == j); }
    
    int main()
    {
        int myints[] = {10, 20, 30, 30, 20, 10, 10, 20};
        vector<int> myvector(myints, myints + 8);
        
        vector<int>::iterator it;
        
        //using default comparrision:
        it = search_n(myvector.begin(), myvector.end(), 2, 30);
        
        if(it != myvector.end())
            cout << "two 30s found at position " << it - myvector.begin() << endl;
        else
            cout << "match not dound" << endl;
        
        //using predicate comparison:
        it = search_n(myvector.begin(), myvector.end(), 2, 10, mypredicate);
        if(it != myvector.end())
            cout << "two 10s found at position " << it - myvector.begin() << endl;
        else
            cout << "match not dound" << endl;
        return 0;
    }
    /*=======================================
     函数输出:two 30s found at position 2
             two 10s found at position 5
     =======================================*/

    二、修改序列函数

    1.copy:

    [first,last)范围中的元素复制到从result开始的范围内。

    /*===================================================
    注:InputIterator/OutputIterator分别是输入迭代器和输出
        迭代器,可以理解为一个指针类型。
    ===================================================*/
    
    template<class InputIterator, class OutputIterator>
      OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
    {
      while (first!=last) {
        *result = *first;
        ++result; ++first;
      }
      return result;
    }

    函数用例

    /*==================================================================
     函数操作:copy()
     函数形参:将迭代器输入到序列中的初始位置和最终位置。使用的范围是[first1,last1).
             将迭代器输出到目标序列中的初始位置,但不应该是[first1,last1)范围内的任意元素
     函数返回:到目标范围末尾的迭代器(指向复制的最后一个元素之后的元素),其中元素已被复制。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        int myints[] = {10, 20, 30, 30, 20, 10, 10, 20};
        vector<int> myvector(7);   //输出容器大小应能存储全部复制数据
        
        copy(myints, myints + 7, myvector.begin());
        
        cout << "myvector contains: ";
        for(int i = 0; i < myvector.size(); i++)
            cout << myvector[i] << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 10 20 30 30 20 10 10
     =======================================*/
    

    2.swap:

    交换两个对象的值

    template <class T> void swap ( T& a, T& b )
    {
      T c(a); a=b; b=c;
    }
    template <class T, size_t N> void swap (T (&a)[N], T (&b)[N]) 
    {
      for (size_t i = 0; i<N; ++i) swap (a[i],b[i]);
    }

    函数用例:

    /*==================================================================
     函数操作:swap()
     函数形参:两个对象,其内容被交换
     函数返回:无
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool mypredicate(int i, int j) { return (i == j); }
    
    int main()
    {
        int x = 10, y = 20;
        swap(x, y);
        
        vector<int> foo(4, x), bar(6, y);
        swap(foo, bar);
        
        cout << "foo contains: ";
        for(vector<int>::iterator it = foo.begin(); it < foo.end(); it++)
            cout << *it << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:foo contains: 10 10 10 10 10 10
     =======================================*/
    

    3.swap_rangs

    [first1,last1)范围中每个元素的值,与从first2开始的相同范围的对应位置的各个元素值进行交换。

    template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                                    ForwardIterator2 first2)
    {
      while (first1!=last1) {
        swap (*first1, *first2);
        ++first1; ++first2;
      }
      return first2;
    }

    函数用例

    /*==================================================================
     函数操作:swap_ranges()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             first2-将迭代器转发到要交换的其他序列中的初始位置。使用的范围包括与范围[first1,last1]相同数量的元素。
             两个范围不得重叠
     函数返回:在第二个序列中参与交换的最后一个元素的下一个元素的迭代器
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        vector<int> myvector1;
        for(int i = 1; i <= 5; i++)
            myvector1.push_back(i);
        vector<int> myvector2;
        for(int i = 6; i <= 10; i++)
            myvector2.push_back(i);
        
        vector<int>::iterator it;
        it = swap_ranges(myvector1.begin() + 1, myvector1.end() - 1, myvector2.begin());
        cout << *it << endl;
        
        // print out results of swap:
        cout << "myvector1 contains:";
        for (it = myvector1.begin(); it != myvector1.end(); ++it)
            cout << *it << ' ';
        cout << endl;
        
        cout << "myvector2 contains:";
        for (it = myvector2.begin(); it != myvector2.end(); ++it)
            cout << *it << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector1 contains:1 6 7 8 5
             myvector2 contains:2 3 4 9 10
     =======================================*/
    

    4.reverse:

    反转[first,last)范围中元素的顺序。

    template <class BidirectionalIterator>
      void reverse (BidirectionalIterator first, BidirectionalIterator last)
    {
      while ((first!=last)&&(first!=--last)) {
        std::iter_swap (first,last);
        ++first;
      }
    }

    函数用例

    /*==================================================================
     函数操作:reverse()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             BidirectionalIterator 指向交换类型是否正确定义
     函数返回:无
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        vector<int> myvector1;
        for(int i = 1; i <= 5; i++)
            myvector1.push_back(i);
        vector<int> myvector2;
        for(int i = 6; i <= 10; i++)
            myvector2.push_back(i);
        
        reverse(myvector1.begin(), myvector1.end());
        reverse(myvector2.begin() + 1, myvector2.end() - 1);
        
        // print out results of swap:
        vector<int>::iterator it;
        cout << "myvector1 contains:";
        for (it = myvector1.begin(); it != myvector1.end(); ++it)
            cout << *it << ' ';
        cout << endl;
        
        cout << "myvector2 contains:";
        for (it = myvector2.begin(); it != myvector2.end(); ++it)
            cout << *it << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector1 contains:5 4 3 2 1
             myvector2 contains:6 9 8 7 10
     =======================================*/
    

    5.replace

    用new_value替换范围内[first,last)所有等于old_value的元素。

    template <class ForwardIterator, class T>
      void replace (ForwardIterator first, ForwardIterator last,
                    const T& old_value, const T& new_value)
    {
      while (first != last) {
        if (*first == old_value) *first = new_value;
        ++first;
      }
    }

    函数用例

    /*==================================================================
     函数操作:replace()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             old_value 要替换的值
             new_valye 替换的值
     函数返回:无
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        int myints[] = {10 ,20 ,30 ,30, 20, 10, 10, 20};
        vector<int> myvector(myints, myints + 7);
        
        replace(myvector.begin(), myvector.end(), 20, 99);
        
        cout << "myvector contains: ";
        for(vector<int>::iterator it = myvector.begin(); it < myvector.end(); it++)
            cout << *it << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 10 99 30 30 99 10 10
     =======================================*/
    

    6.replace_if

    在[first,last)范围内的元素,通过 pred函数后返回值为 TRUE的元素,用 value 来替换。

    template < class ForwardIterator, class UnaryPredicate, class T >
      void replace_if (ForwardIterator first, ForwardIterator last,
                       UnaryPredicate pred, const T& new_value)
    {
      while (first!=last) {
        if (pred(*first)) *first=new_value;
        ++first;
      }
    }

    函数用例:

    /*==================================================================
     函数操作:replace_if()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             pred-一元函数接受范围内的元素作为参数,并返回可转换为的值bool。返回的值表示是否要替换元素(如果true替换它)。
             该函数不得修改其参数。
             这可以是函数指针或函数对象。
             value-要替换的值
     函数返回:无
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    //using namespace std;
    
    bool IsOdd (int i) { return ((i % 2) == 1); }
    
    int main () {
        std::vector<int> myvector;
        
        // set some values:
        for (int i = 1; i < 10; i++) myvector.push_back(i);               // 1 2 3 4 5 6 7 8 9
        
        std::replace_if (myvector.begin(), myvector.end(), IsOdd, 0);      // 0 2 0 4 0 6 0 8 0
        
        std::cout << "myvector contains: ";
        for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); it++)
            std::cout << *it << ' ';
        std::cout << std::endl;
        
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 0 2 0 4 0 6 0 8 0
     =======================================*/
    

    7.remove

    [first,last)范围中所有等于val的元素移除,并将迭代器返回到该范围的新结尾。

    该函数不能改变包含元素范围的对象的属性(即,它不能改变数组或容器的大小):删除是通过将下一个与 val不匹配的元素 前移来替换 val元素来完成的。

    保留了未删除元素的相对顺序,而返回迭代器和last之间的元素保持有效但未指定的状态。

    template <class ForwardIterator, class T>
      ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
    {
      ForwardIterator result = first;
      while (first!=last) {
        if (!(*first == val)) {
          *result = *first;
          ++result;
        }
        ++first;
      }
      return result;
    }

    函数用例

    /*==================================================================
     函数操作:remove()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             value-要删除的值
     函数返回:未删除的最后一个元素后面的元素的迭代器。
             first和this迭代器之间的范围包括序列中不比较等于val的所有元素。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main ()
    {
        int myints[] = {10, 20, 30, 30, 20, 10, 10, 20};
        
        //bounds of rang:
        int* pbegin = myints;
        int* pend = myints + sizeof(myints) / sizeof(int);
        
        pend = remove(pbegin, pend, 20);
        
        cout << "rang contains: ";
        for(int* p = pbegin; p != pend; p++)
            cout << *p << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:rang contains: 10 30 30 10 10
     =======================================*/
    

    8.remove_if

    [first,last)范围中所有pred 返回 TRUE的元素移除,并将迭代器返回到该范围的新结尾

    该函数不能改变包含元素范围的对象的属性(即,它不能改变数组或容器的大小):删除是通过用下一个元素替换pred返回true的元素来完成的。

    template <class ForwardIterator, class UnaryPredicate>
      ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,
                                 UnaryPredicate pred)
    {
      ForwardIterator result = first;
      while (first!=last) {
        if (!pred(*first)) {
          *result = *first;
          ++result;
        }
        ++first;
      }
      return result;
    }

    函数用例

    /*==================================================================
     函数操作:remove_if()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             pred-一元函数接受范围内的元素作为参数,并返回可转换为的值bool。返回的值指示是否要删除元素(如果要删除true它)。
             该函数不得修改其参数。
             这可以是函数指针或函数对象。
     函数返回:未删除的最后一个元素后面的元素的迭代器。
             first和this迭代器之间的范围包括序列中不比较等于val的所有元素。
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool IsOdd (int i) { return ((i % 2) == 1); }
    
    int main ()
    {
        int myints[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        
        //bounds of rang:
        int* pbegin = myints;
        int* pend = myints + sizeof(myints) / sizeof(int);
        
        pend = remove_if(pbegin, pend, IsOdd);
        
        cout << "rang contains: ";
        for(int* p = pbegin; p != pend; p++)
            cout << *p << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:rang contains: 2 4 6 8
     =======================================*/
    

    9.unique:

    删除范围内的连续重复项
    从[first,last)范围中的每个连续的等效元素组中删除除第一个元素之外的所有元素。

    该函数不能改变包含元素范围的对象的属性(即,它不能改变数组或容器的大小):通过用下一个不重复的元素替换重复元素来完成删除,并且通过将迭代器返回到应该被视为其新的past-the-end元素来发信号通知缩短范围的新大小,即删除重复元素后最后一个元素的下一个元素位置。

    保留未删除元素的相对顺序,而返回的迭代器和last之间的元素保留在有效但未指定的状态。

    equality (1)
    template <class ForwardIterator>
      ForwardIterator unique (ForwardIterator first, ForwardIterator last);
    
    predicate (2)
    template <class ForwardIterator, class BinaryPredicate>
      ForwardIterator unique (ForwardIterator first, ForwardIterator last,
                              BinaryPredicate pred);
    template <class ForwardIterator>
      ForwardIterator unique (ForwardIterator first, ForwardIterator last)
    {
      if (first==last) return last;
    
      ForwardIterator result = first;
      while (++first != last)
      {
        if (!(*result == *first))  // or: if (!pred(*result,*first)) for version (2)
          *(++result)=*first;
      }
      return ++result;
    }

    函数用例

    // unique algorithm example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::unique, std::distance
    #include <vector>       // std::vector
    
    bool myfunction (int i, int j) {
      return (i==j);
    }
    
    int main () {
      int myints[] = {10,20,20,20,30,30,20,20,10};           // 10 20 20 20 30 30 20 20 10
      std::vector<int> myvector (myints,myints+9);
    
      // using default comparison:
      std::vector<int>::iterator it;
      it = std::unique (myvector.begin(), myvector.end());   // 10 20 30 20 10 ?  ?  ?  ?
                                                             //                ^
    
      myvector.resize( std::distance(myvector.begin(),it) ); // 10 20 30 20 10
    
      // using predicate comparison:
      std::unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)
    
      // print out content:
      std::cout << "myvector contains:";
      for (it=myvector.begin(); it!=myvector.end(); ++it)
        std::cout << ' ' << *it;
      std::cout << '\n';
    
      return 0;
    }

     


    四、排序

    1.sort:

    [first,last) 范围中的元素按升序排列

    default (1)
    template <class RandomAccessIterator>
      void sort (RandomAccessIterator first, RandomAccessIterator last);
    
    custom (2)
    template <class RandomAccessIterator, class Compare>
      void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

    函数用例

    /*==================================================================
     函数操作:remove_if()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             RandomAccessIterator 是能在常数时间内移动到指向任何元素的位置
             comp-二进制函数,接受范围中的两个元素作为参数,并返回可转换为的值bool。返回的值表示作为第一个参数传递的元素是否被认为是在它定义的特定严格弱顺序中的第二个参数之前。
             该函数不得修改其任何参数。
             这可以是函数指针或函数对象。
     函数返回:无
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    //using namespace std;
    
    bool myfunction (int i,int j) { return (i<j); }
    
    struct myclass {
        bool operator() (int i,int j) { return (i<j);}
    } myobject;
    
    int main () {
        int myints[] = {32,71,12,45,26,80,53,33};
        std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33
        
        // using default comparison (operator <):
        std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33
        
        // using function as comp
        std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
        
        // using object as comp
        std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)
        
        // print out content:
        std::cout << "myvector contains:";
        for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
            std::cout << ' ' << *it;
        std::cout << '\n';
        
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 12 26 32 33 45 53 71 80
     =======================================*/

    2.stable_sort:

    将范围中的元素[first,last)按升序排序,如sort,但stable_sort保留具有等效值的元素的相对顺序

    template <class RandomAccessIterator>
      void stable_sort ( RandomAccessIterator first, RandomAccessIterator last );
    
    template <class RandomAccessIterator, class Compare>
      void stable_sort ( RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp );

    函数用例

    /*==================================================================
     函数操作:stable_sort()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             RandomAccessIterator 是能在常数时间内移动到指向任何元素的位置
             comp-二进制函数,接受范围中的两个元素作为参数,并返回可转换为的值bool。返回的值表示作为第一个参数传递的元素是否被认为是在它定义的特定严格弱顺序中的第二个参数之前。
             该函数不得修改其任何参数。
             这可以是函数指针或函数对象。
     函数返回:void
     =================================================================*/
    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    bool compare_as_ints (double i,double j)
    {
        return (int(i)<int(j));                    //只舍不进位
    }
    
    int main ()
    {
        double mydoubles[] = {3.14, 1.41, 2.72, 4.67, 1.73, 1.32, 1.62, 2.58};
        
        vector<double> myvector;
        
        myvector.assign(mydoubles, mydoubles+8);
        
        cout << "using default comparison:";
        stable_sort (myvector.begin(), myvector.end());
        for (vector<double>::iterator it = myvector.begin(); it != myvector.end(); it++)
            cout << ' ' << *it;
        cout << endl;
        
        myvector.assign(mydoubles, mydoubles+8);   //第一次排序后再次赋值
        
        cout << "using 'compare_as_ints' :";
        stable_sort (myvector.begin(), myvector.end(), compare_as_ints);
        for (vector<double>::iterator it = myvector.begin(); it != myvector.end(); it++)
            cout << ' ' << *it;
        cout << '\n';
        
        return 0;
    }
    /*=======================================
     函数输出:using default comparison: 1.32 1.41 1.62 1.73 2.58 2.72 3.14 4.67
             using 'compare_as_ints' : 1.41 1.73 1.32 1.62 2.72 2.58 3.14 4.67
     =======================================*/
    

     


    八、最大/最小

    1.max_element / min_element

    返回指向范围[first,last)中具有最大值的元素的迭代器。

    default (1)
    template <class ForwardIterator>
      ForwardIterator max_element (ForwardIterator first, ForwardIterator last);
    
    custom (2)
    template <class ForwardIterator, class Compare>
      ForwardIterator max_element (ForwardIterator first, ForwardIterator last,
                                   Compare comp);
    template <class ForwardIterator>
      ForwardIterator max_element ( ForwardIterator first, ForwardIterator last )
    {
      if (first==last) return last;
      ForwardIterator largest = first;
    
      while (++first!=last)
        if (*largest<*first)    // or: if (comp(*largest,*first)) for version (2)
          largest=first;
      return largest;
    }

    函数用例

    /*==================================================================
     函数操作:max_element()
     函数形参:将前向迭代器转发到要交换的序列之一的初始位置和最终位置。使用的范围是[first1,last1]
             RandomAccessIterator 是能在常数时间内移动到指向任何元素的位置
             comp-二进制函数,接受范围中的两个元素作为参数,并返回可转换为的值bool。返回的值表示作为第一个参数传递的元素是否被认为是在它定义的特定严格弱顺序中的第二个参数之前。
             该函数不得修改其任何参数。
             这可以是函数指针或函数对象。
     函数返回:范围中最大值的迭代器,如果范围为空,则返回 last
     =================================================================*/
    #include <iostream>
    //#include <vector>
    #include <algorithm>
    //using namespace std;
    
    bool myfn(int i, int j) { return i<j; }
    
    struct myclass {
        bool operator() (int i,int j) { return i<j; }
    } myobj;
    
    int main () {
        int myints[] = {3,7,2,5,6,4,9};
        
        // using default comparison:
        std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
        std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';
        
        // using function myfn as comp:
        std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
        std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';
        
        // using object myobj as comp:
        std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
        std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';
        
        return 0;
    }
    /*=======================================
     函数输出:The smallest element is 2
             The largest element is 9
             The smallest element is 2
             The largest element is 9
             The smallest element is 2
             The largest element is 9
     =======================================*/
    

     

    展开全文
  • 这里首先介绍一个万能头文件: include<bits/stdc++.h> 一个头文件解决了一切,接下来为了方便都使用这个头文件 1.max,min函数 代码: #include<bits/stdc++.h>...using namespace std;...

    这里首先介绍一个万能头文件:

    include<bits/stdc++.h>

    在这里插入图片描述
    一个头文件解决了一切,接下来为了方便都使用这个头文件

    1.max,min函数

    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int a[2]={1,2};
         printf("max=%d\n",max(a[1],a[0]));
         printf("min=%d\n",min(a[1],a[0]));
    	return 0;
    } 
    

    运行结果:
    在这里插入图片描述

    2.swap函数

    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int a[2]={1,2};
         swap(a[0],a[1]);
         printf("%d %d",a[0],a[1]);
    	return 0;
    } 
    

    运行结果:
    在这里插入图片描述

    3.abs()函数(求绝对值)

    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int a[2]={1,-2};
         printf("%d %d",a[0],abs(a[1]));
    	return 0;
    } 
    

    结果:
    在这里插入图片描述

    4.reverse()函数

    reverse(it, it+a)可以将数组指针在[it, it+a)之间的元素或容器的迭代器在[it, it2)范围内的元素进行反转
    a=需要反转数的个数
    代码:

    整型数反转:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int a[10]={0,1,2,3,4,5,6,7,8,9};
         reverse(a,a+10);
         for(int i=0;i<10;i++)
         printf("%d ",a[i]);
    	return 0;
    } 
    

    结果:
    在这里插入图片描述

    字符串反转:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	char a[10]={"abcdefghi"};
         reverse(a,a+9);
         puts(a);
    	return 0;
    } 
    

    结果:
    在这里插入图片描述

    5.next_permutation函数(全排列)

    使用条件:排好序
    next_permutation(t1,t1+a)可以对数组指针[t1,t1+a]之间的元素进行全排列,也就是"a=全排列的长度"
    字符串全排列:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	char a[10]={"abc"};
        do
        {
        	 puts(a);
        }while(next_permutation(a,a+3));
    	return 0;
    } 
    

    运行结果:
    在这里插入图片描述

    若改成:

    next_permutation(a,a+2)

    运行结果:
    在这里插入图片描述
    若改成原始字典序就是降序

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	char a[10]={"cba"};
        do
        {
        	 puts(a);
        }while(next_permutation(a,a+3));
    	return 0;
    } 
    

    运行结果:
    在这里插入图片描述
    所以在此强调(使用这个函数原始顺序最好是字典序升序)!!!!

    6.fill()函数

    fill(it,it+a)可以把数组或容器中的某一段区间赋为某个相同的值。和memset不同,这里的赋值可以是数组类型对应范围中的任意值。
    a=赋值的个数
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int a[5]={1,5,6,7,3};
         fill(a,a+5,999);//将a[0]~a[4]赋值3为999 
         for(int i=0;i<5;i++)
         printf("%d ",a[i]);
    	return 0;
    } 
    

    结果:
    在这里插入图片描述

    7.lower_bound(begin,end,num)函数

    使用条件:排好序
    从数组的begin位置到end-1位置二分查找第一个大于等于num的数组,找到返回该数组地址,不存在则返回end。通过返回的地址减去起始地址begin,得到数字在数组中的下标。
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int x;
    	int a[5]={1,2,3,4,5};
         x=lower_bound(a,a+5,3)-a;
         printf("%d ",x);
    	return 0;
    } 
    

    结果:
    在这里插入图片描述
    注意:如果使用次函数查找某一个数,没有找到只会返回第一个比这个数大的数的下标,要是判断有没有找到,可以用返回下标的数和需要查找的数进行对比即可

    8.upper_bound(begin,end,num)函数

    使用条件:排好序
    从数组的begin位置到end-1位置二分查找第一个大于num的数组,找到返回该数组地址,不存在则返回end。通过返回的地址减去起始地址begin,得到数字在数组中的下标。
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int x;
    	int a[5]={1,2,3,4,5};
         x=upper_bound(a,a+5,4)-a;
         printf("%d ",x);
    	return 0;
    } 
    

    结果:
    在这里插入图片描述

    9.unique(去重)
    先排序,然后用尺取法

    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main(){
    	int a[5]={1,1,2,2,3};
    	int n = unique(a,a+5)-a;
    	for(int i=0;i<5;i++){
    		printf("%d ",a[i]);
    	}
    	printf("\n我们只取n之前的数:\n");
    	for(int i=0;i<n;i++){
    		printf("%d ",a[i]);
    	}
    	return 0;
    } 
    

    在这里插入图片描述
    注意:不能去重后排序

    展开全文
  • algorithm头文件下常用函数

    万次阅读 多人点赞 2018-04-23 21:40:48
    algorithm头文件下常用函数 1. max(),min(),abs() max(x,y)和min(x,y)分别返回x和y中的最大值和最小值,且参数必须是两个。 abs(x) 返回x的绝对值。x必须为整数,浮点型的绝对值要用math头文件下的fabs 2. ...

    algorithm头文件下常用函数

    1. max(),min(),abs()

    max(x,y)和min(x,y)分别返回x和y中的最大值和最小值,且参数必须是两个。
    abs(x) 返回x的绝对值。x必须为整数,浮点型的绝对值要用math头文件下的fabs

    2. swap()

    swap(x,y)用来交换x和y的值

    3. reverse()

    reverse(it,it2) 可以将数组指针在[it,it2)之间的元素或容器的迭代器在[it,it2)范围内的元素进行反转。

    #include<stdio.h>
    #include<algorithm>
    using namespace std;
    int main()
    {
        int a[10]={10,11,12,13,14,15};
        reverse(a,a+4);
        for(int i=0;i<6;i++){
            printf("%d ",a[i]);
        }
        return 0;
    }
    
    #include<stdio.h>
    #include<string>
    #include<algorithm>
    using namespace std;
    int main()
    {
        string str="abcdefghi";
        reverse(str.begin()+2,str.begin()+6);
        for(int i=0;i<str.length();i++){
            printf("%c",str[i]);
        }
        return 0;
    }
    

    4. next_permutation()

    next_permutation() 给出一个序列在全排列中的下一个序列

    #include<stdio.h>
    #include<string>
    #include<algorithm>
    using namespace std;
    int main()
    {
        int a[10]={1,2,3};
        do{
            printf("%d %d %d\n",a[0],a[1],a[2]);
        }while(next_permutation(a,a+3));
        return 0;
    }
    

    5. fill()

    fill() 可以把数组或容器中的某一段区间赋为某个相同的值。和memset不同,这里的赋值可以使数组类型对应范围中的任意值。

    #include<stdio.h>
    #include<string>
    #include<algorithm>
    using namespace std;
    int main()
    {
        int a[10]={1,2,3,4,5};
        fill(a,a+5,233);
        for(int i=0;i<5;i++){
            printf("%d ",a[i]);
        }
        return 0;
    }
    

    6. sort()

    默认为递增排序
    * 若要递减排序,需要增加比较函数

    bool cmp(int a,int b){
      return a>b;
    }
    sort(a,a+n,cmp);
    • 结构体数组排序
    struct node{
      int x,y;
    }a[10];
    bool cmp(node a,node b){
      return a.x>b.x; 
    }
    //
    bool cmp(int x,int y){
      if(a.x!=b.x) return a.x>b.x;
      else return a.y<b.y;
    }
    • 容器排序,在STL标砖容器中,只有vector/string/deque可以sort
    #include<stdio.h>
    #include<string>
    #include<vector>
    #include<algorithm>
    using namespace std;
    bool cmp(int a,int b){
        return a>b;
    }
    int main()
    {
        vector<int> vi;
        vi.push_back(3);
        vi.push_back(1);
        vi.push_back(2);
        sort(vi.begin(),vi.end(),cmp);
        for(int i=0;i<3;i++){
            printf("%d ",vi[i]);
        }
        return 0;
    }
    

    7. lower_bound()和upper_bound()

    lower_bound 和 upper_bound()需要用在一个有序数组或容器中。
    lower_bound(first,last,val) 用来寻找在数组或容器的[first,last)范围内第一个值大于等于
    val元素的位置,如果是数组,返回该位置的指针;若果是容器,返回该位置的迭代器
    upper_bound(first,last,val) 用来寻找在数组或容器的[first,last)范围内第一个值大于
    val元素的位置,如果是数组,返回该位置的指针;若果是容器,返回该位置的迭代器

    #include<stdio.h>
    #include<string>
    #include<vector>
    #include<algorithm>
    using namespace std;
    int main()
    {
        int a[10]={1,2,2,3,3,3,5,5,5,5};
        printf("%d,%d\n",lower_bound(a,a+10,3)-a,upper_bound(a,a+10,3)-a);
        return 0;
    }
    
    展开全文
  • Algorithm(算法)

    千次阅读 2018-08-03 10:56:51
    1、泛型算法通则 所有算法的前两个参数都是一对iterators:[frist,last),用来指出容器内一个范围内的元素 每个算法的声明中,都表现出它所需要的最低层次的iterator类型。 大部分算法都可以用functioin object...
  • Algorithm1

    2019-07-19 17:26:45
    算法基础重构: 1.1基础编程模型 1.1.1java程序基本结构 原始数据类型:它们在计算机程序中精确定义整数,浮点数,布尔值。 语句:程序通过语句执行实现功能:6种语句(声明,赋值,条件,循环,调用,返回) ...
  • c++中的algorithm

    千次阅读 2018-08-18 22:36:58
    c++中的algorithm库,包含了所有vector、list、set、map操作能想到的一些函数,如查找,替换、排序、计数等常用的功能全部在里面,在这里虽然不像Java那样完全面向对象,方法全部在类里面,但是熟读algorithm库还是...
  • 【C/C++】【Algorithm

    千次阅读 2019-06-19 21:05:50
    人民公园的门口有10级台阶,如果一次只能上一级或2级台阶,一共有多少种上法_作业帮 这数学题能不能用C语言解题-CSDN论坛
  • 相关文章Algorithm:【Algorithm算法进阶之路】之数据结构二十多种算法演示Algorithm:【Algorithm算法进阶之路】之十大经典排序算法Algorithm:【Algorithm算法进阶之路】之数据结构基础知识Algorithm:【Algorithm...
  • c++ algorithm 函数简介

    万次阅读 2016-05-17 20:57:28
    algorithm编辑 algorithm意为"演算法",是C++的标准模版库(STL)中最重要的头文件之一,提供了大量基于迭代器的非成员模版函数。 编程语言C++ 类 别C++标准库 头文件#include 命名空间using namespace std; ...
  • C++/C++11中头文件algorithm的使用

    万次阅读 2017-09-19 21:44:34
    algorithm>是C++标准程序库中的一个头文件,定义了C++ STL标准中的基础性的算法(均为函数模板)。<algorithm>定义了设计用于元素范围的函数集合。任何对象序列的范围可以通过迭代器或指针访问。 std::...
  • C/C++中常库函数-#include<algorithm>

    千次阅读 多人点赞 2018-01-26 11:36:00
    //algorithm意为"算法",是C++的标准模版库(STL)最重要的头文件之一,提供了大量基于迭代器的非成员模板函数。点击:&lt;math.h&gt;函数用法 &lt;string.h&gt;函数用法#include&...
  • 而我们也可以直接使用在函数下的sort函数,只需加上头文件: #include<algorithm> using namespace std; sort格式:sort(首元素地址,尾元素的下一个地址,比较函数) 注:比较函数不一定要有,sort函数默认...
  • Optimization-Algorithm 优化算法--C语言 A Record for the Methods of Optimization.(优化算法--C语言) Author: Amoiensis Email:Amoiensis@outlook.com Data:2020.05.27 更多资料和信息Github: ...
  • Luhn algorithmFrom Wikipedia, the free encyclopediaThe Luhn algorithm or Luhn formula, also known as the "modulus 10" or "mod 10" algorithm, is a simple checksum formula used to validate a va
  • Algorithm学习笔记 --- C语言实现二分查找
  • Kahan summation algorithm

    千次阅读 2012-01-11 21:13:06
    In numerical analysis, theKahan summation algorithm (also known ascompensated summation) significantly reduces thenumerical error in the total obtained by adding asequence of finiteprecisionfloating
  • Latex 中algorithm2e 使用例子

    万次阅读 2012-09-17 15:34:42
    網路上查了很多資料關於"LaTeX寫algorithm" 自己稍微整理一下 algorithm排版可能需要的套件 \documentclass[journal]{IEEEtran} \usepackage{algorithm} %\usepackage{algorithmic} \usepackage{...
  • algorithm库函数集合

    千次阅读 2019-03-30 21:20:42
    不修改内容的序列操作: 修改内容的序列操作: 划分操作: 排序操作: 二分法查找操作: 集合操作: 堆操作: 最大/最小操作: 附上 巡防算法 for_each(容器起始地址,容器结束地址...al...
  • c++sort函数有两种形式 sort (first, last) //两个参数 sort (first, last, cmp) //三个参数 下面先说第一种 #include<iostream> #include <algorithm> using namespace std; int main(){ int a...
  • 讲解头文件 66 个函数的功能
  • #include<stdio.h> int main(){ int a[1001]; for(int q=0;q<=1000;q++){ a[q]=0; } int digit=1,num=0,temp=0; a[0]=1; int i=2; for(;i<=50;i++){ f...
  • Algorithm

    2015-03-08 15:48:27
    **算法刷题网站**1、leetcode 2、glassdoor 3、topcoder 4、careerup 5、zoj 6、codeforces 7、poj
  • Data Structures and Algorithm Analysis in C, SecondEdition数据结构和算法分析C语言版(第二版)by Mark Allen Weiss作者: Mark Allen Weiss PREFACE卷首语 CHAPTER1: INTRODUCTION第一章: 简介CHAPTER2: ...
  • algorithm

    千次阅读 2011-12-01 18:17:07
    algorithm ['ælɡəriðəm]算法 genetic algorithm遗传算法 encryption algorithm加密算法 pseudo ['psju:dəu] n. 伪君子;假冒的人adj. 冒充的,假的 pseudo-terminal 伪终端
  • Algorithm2e是一种Latex2e的算法编写环境,算法描述被定义为像图片一样的浮动对象。它提供了大量的宏命令允许你创建不同类型的关键字,因此预先提供了一系列的关键字。甚至也可以改变关键字的排版。
  • // 使用find()函数查找自定义类型的数据.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;string&...
  • algorithm中sort函数的使用

    千次阅读 2017-07-05 22:27:07
    只有定义为vector型变量,才可以使用第一种形式; 第二种形式,需自己定义数组元素比较大小的方式,函数返回类型为bool,调用时,只需函数名,不要加() sort(a.begin(),a.end) sort(a.begin(),a.end,myfun) #...
  • 函数lower_bound()first和last的前闭后开区间进行二分查找,返回大于或等于val的第一个元素位置。如果所有元素都小于val,则返回last的位置,且last的位置是越界的 返回查找元素的第一个可安插位置,也就是...
  • STL algorithm中的swap 函数使用

    千次阅读 2015-08-15 17:58:02
    对自定义类型使用STL algorithm中的swap函数, 会调用自定义的类型的拷贝构造函数一次,赋值函数两次;自定义类型没有定义那么就会使用默认的拷贝构造函数和赋值函数。  如果是容器,那么会遍历容易进行赋值。 ...

空空如也

1 2 3 4 5 ... 20
收藏数 1,201,714
精华内容 480,685
关键字:

algorithm