algorithm（算法）

algorithm（算法）

STL中算可以分为三种，

　　1、变序型队列算法,可以改变容器内的数据；

　　2、非变序型队列算法,处理容器内的数据而不改变他们 ；

　　3、通用数值算法，这涉及到很多专业领域的算术操作，这里不做介绍。

　　第一是变序型算法，这种算法可以改变容器内的数据，而且可以只对容器的一部分数据进行操作。常用的有copy，reverse，swap，replace等，用法如下：

　　首先看看copy函数,是将某一范围的数据拷贝到新的容器中

_OutIt copy(_InIt _First, _InIt _Last,_OutIt _Dest);    // copy [_First, _Last) to [_Dest, ...)

　　可写如下代码实现：

　　 int arr[6] = {1,12,3,2,1215,90};
    int arr1[7];
    copy(arr,arr+6,arr1);//(0-5)将arr中前六个数据拷贝到arr1中
    cout<<"将arr[6]copy到arr[1]："<<endl;
    for (int i = 0;i < 6;i ++)
    {
        cout<<arr1[i]<<"  ";
    }

　　接下来看reverse函数，将容器中数据反转

  void reverse(_BidIt _First, _BidIt _Last);// reverse elements in [_First, _Last)

　　看代码如何实现：

　　 reverse(arr,arr+6);//将arr中前六个数据反转,
    cout<<"\n将arr数据反转："<<endl;
    for (int i = 0;i < 6;i ++)
    {
        cout<<arr[i]<<"  ";
    }

　　现在看swap，swap_range函数,交换两个空间大小相同的容器的数据

_FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _Dest);// swap [_First1, _Last1) with [_Dest, ...)

　　代码如下：

swap_ranges(arr,arr+6,arr1);//交换两个空间大小相同的容器

　　继续replace函数，替换某个元素

void replace(_FwdIt _First, _FwdIt _Last,const _Ty& _Oldval, const _Ty& _Newval);// replace each matching _Oldval with _Newval

　　使用如下：

replace(arr1,arr1+2,12,100);//替换12为100

　　最后说一下ostream_iterator,用于直接从容器中输出数据，第一个参数是输出流，第二个是数据之间的分隔符

    ostream_iterator(ostream_type& _Ostr,
        const _Elem *_Delim = 0)
        : _Myostr(&_Ostr), _Mydelim(_Delim)
        {    // construct from output stream（输出流） and delimiter（分隔符）
        }

　　使用方法如下：

    cout<<"\narr1:"<<endl;
    copy(arr1,arr1+6,ostream_iterator<int>(cout,"  "));
    replace(arr1,arr1+2,12,100);//替换某数据
    cout<<"\n after replace, arr1:"<<endl;
    copy(arr2,arr1+6,ostream_iterator<int>(cout,"  "));

　　第二种是不可修改型算法，这种算法之对数据进行，查找，排序，搜索等操作

　　首先来看查找find函数,查找第一个符合条件的值，若找到成功，返回指向改值的迭代器，没有找到，指向v1.end()

    _InIt find(_InIt _First, _InIt _Last, const _Ty& _Val);// find first matching _Val

　　使用方法：

    int a[10] = {12,31,5,2,23,121,0,89,34,66};
    vector<int> v1(a,a+10);
    vector<int>::iterator result1,result2;//随机访问迭代器
    result1 = find(v1.begin(),v1.end(),2);//若找到成功，返回指向2的迭代器
    result2 = find(v1.begin(),v1.end(),8);//没有找到，指向v1.end()

    if ((result1 - v1.begin())<10)//结果小于10，说明数据存在
    {
        cout<<"find it"<<endl;
        cout<<*result1<<endl;
    }
    else
        cout<<"not find it"<<endl;

    cout<<result2 - v1.begin()<<endl;//10，说明没有找到

　　接着看搜索函数search，搜索区间2中数据是否有在区间1里的，有的话返回区间1里第一个找到的值的位置

_FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2);// find first [_First2, _Last2) match

　　用法如下：

    int b[9]={5,2,23,54,5,5,5,2,2};
    vector<int> v2(a+2,a+8);
    vector<int> v3(b,b+4);
    //在v1中找到序列v2，result1指向v2在v1中开始的位置，就是指向找到的第一个元素
    result1=search(v1.begin(),v1.end(),v2.begin(),v2.end());
    cout<<*result1<<endl;//找到并输出
    //在v1中没有找到序列v3，result1指向v1中结束的位置，v1.end（）
    result1=search(v1.begin(),v1.end(),v3.begin(),v3.end());
    cout<<*(result1-1)<<endl;//没有找到，返回最后一个值

　　现在看排序算法sort,默认升序排列

　　 template<class _RanIt> inline
    void sort(_RanIt _First, _RanIt _Last);// order [_First, _Last), using operator<

　　用法如下：

　　 int d[10]={12,0,5,3,6,8,9,34,32,18};
    int e[5]={5,3,6,8,99};
    int f[15];

    sort(d,d+10);
    for(int i=0;i<10;i++)
        cout<<" "<<d[i];
    cout<<endl;
    sort(e,e+5);
    for(int i=0;i<5;i++)
        cout<<" "<<e[i];

　　最后看一下include函数，用来判断一个容器中的数据是否全在另一个容器里,默认也是升序

// test if all [_First1, _Last1) in [_First2, _Last2), using operator<

bool includes(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2);

　　使用如下：

    if (includes(d,d+10,e,e+5))//e中数据是否全部在d中
    {
        cout<<"\n sorted b elements are included in a ."<<endl;
    }
    else
        cout<<"\n b elements are not included in a ."<<endl;

　　常用算法就这么多，下一章看看神奇的迭代器

　　

 

 

分类: C++, STL

标签: C++, STL