C++泛型算法中常用函数

最新推荐文章于 2024-08-13 13:28:29 发布

红鲤鱼遇绿鲤鱼

最新推荐文章于 2024-08-13 13:28:29 发布

阅读量926

点赞数

分类专栏： c/c++语言学习文章标签： C++ C++11 泛型算法基本操作

本文链接：https://blog.csdn.net/tengfei461807914/article/details/52325241

版权

c/c++语言学习专栏收录该内容

21 篇文章 6 订阅

订阅专栏

所谓泛型算法

实际上就是一系列通用的操作，这些操作大多数独立于任何特定的容器，是通用的，所以叫做泛型算法。
泛型算法包含的非常多，这里只记一些基本的操作。lambda表达式，闭包操作操作和其他迭代器以及配合使用的操作，后序再记录。

查找：

find函数用来查找一定范围内的一个元素，数据有序无序都可以，如果要查找的类型不是基本数据类型，需要重载运算符==

find函数的源码如下，很好理解。

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

三种例子，分别是查找数组，查找容器，查找自己定义的类型
代码来自cpp官网，修改过

#include <bits/stdc++.h>
using namespace std;
struct node
{
    int x;
    bool operator == (const node &n) const {return this->x==n.x;}
};
int main()
{
    ios::sync_with_stdio(false);
    //使用指针
    int myints[]={ 10, 20, 30, 40 };
    int* p;
    p=find(myints, myints+4, 30);
    if(p!=myints+4)
        cout<<*p<<endl;

    //或者可以这样
    auto pp=find(begin(myints),end(myints),30);//返回的是一个指针
    if(pp!=end(myints))
        cout<<*pp<<endl;
    // 使用迭代器
    vector<int> myvector (myints,myints+4);
    vector<int>::iterator it;

    it=find(myvector.begin(), myvector.end(), 30);
    if(it!=myvector.end())
        cout<<*it<<'\n';

    //自己定义的类型
    vector<node> ve;
    for(int i=0;i<10;i++)
        ve.push_back(node{i});
    node mark;
    mark.x=3;
    auto pos=find(ve.begin(),ve.end(),mark);
    if(pos!=ve.end())
        cout<<pos->x<<endl;
    return 0;
}

查找函数还有lower_bound、binary_search等函数，后序记录。

排序：

c++中最经常使用的算法应该就是排序算法，也就是sort函数。当然还有有partial_sort
以及stable_sort，并不常用，后序介绍。

sort函数排序默认是从小到大，如果想给自定义类型排序，可以重载运算符或者自定义比较函数。

#include <bits/stdc++.h>
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 ()
{
    ios::sync_with_stdio(false);
    int myints[] = {32,71,12,45,26,80,53,33};
    //不使用迭代器给数组排序
    sort(begin(myints),end(myints));
    //或者如下，效果相同
    sort(myints,myints+8);

    //如果使用迭代器，那么最好放在容器当中操作
    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)

    return 0;
}

去重：

unique的作用是剔除相邻元素之间的重复元素。
unique函数可以实现在排好序的情况对数据进行去重，如果是自定义类型，需要重载运算符。
不过unique的去重并不是真正的删除重复的元素，而是把重复的元素放到后面，配合erase函数可以起到去重重复元素的作用。

源码如下（很经典哦，面试的时候一般都喜欢出这样的，呵呵）

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

例子：
代码来自cpp官网

#include <bits/stdc++.h>
using namespace std;
bool myfunction (int i, int j) {
  return (i==j);
}

int main ()
{
    ios::sync_with_stdio(false);

    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 ?  ?  ?  ?
                                                           //                ^
    //distance函数是计算两个迭代器之间的距离，算出后用resize重新分配内存达到删除重复的目的
    myvector.resize( std::distance(myvector.begin(),it) ); // 10 20 30 20 10

    // 自定义操作
    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;
}

简单的去重代码

#include <bits/stdc++.h>
using namespace std;

int main ()
{
    ios::sync_with_stdio(false);
    vector<int> ve={1,2,3,4,2,4,1,3};
    sort(ve.begin(),ve.end());
    auto end_it=unique(ve.begin(),ve.end());
    ve.erase(end_it,ve.end());
    for(auto x:ve)
        cout<<x<<endl;
    return 0;
}

累加：

accumulate函数可以实现对一组能够累加的数据进行累加操作，如果用户重载了运算符，也可以进行类似操作。用户还可以添加自定义的函数操作，用来实现不同方式的累加。

源码如下，其中init为初始值

template <class InputIterator, class T>
   T accumulate (InputIterator first, InputIterator last, T init)
{
  while (first!=last) {
    init = init + *first;  // or: init=binary_op(init,*first) for the binary_op version
    ++first;
  }
  return init;
}

用例，代码来自cpp官网

#include <bits/stdc++.h>
using namespace std;

int myfunction (int x, int y) {return x+2*y;}
struct myclass {
    int operator()(int x, int y) {return x+3*y;}
} myobject;

int main ()
{
    ios::sync_with_stdio(false);
    int init = 100;
    int numbers[] = {10,20,30};

    std::cout << "using default accumulate: ";
    std::cout << std::accumulate(numbers,numbers+3,init);//160
    std::cout << '\n';

    std::cout << "using functional's minus: ";
    //累减
    std::cout << std::accumulate (numbers, numbers+3, init, std::minus<int>());//40
    std::cout << '\n';

    std::cout << "using custom function: ";
    std::cout << std::accumulate (numbers, numbers+3, init, myfunction);//220
    std::cout << '\n';

    std::cout << "using custom object: ";
    std::cout << std::accumulate (numbers, numbers+3, init, myobject);//280
    std::cout << '\n';

    return 0;
}

赋值:

fill函数可以可以向容器当中的一定范围能赋值，一共接受3个参数，类似于memset函数。

源码如下

template <class ForwardIterator, class T>
  void fill (ForwardIterator first, ForwardIterator last, const T& val)
{
  while (first != last) {
    *first = val;
    ++first;
  }
}

使用例子，非常简单

#include <bits/stdc++.h>
using namespace std;

int main ()
{
    ios::sync_with_stdio(false);
    std::vector<int> myvector (8);                       // myvector: 0 0 0 0 0 0 0 0

    std::fill (myvector.begin(),myvector.begin()+4,5);   // myvector: 5 5 5 5 0 0 0 0
    std::fill (myvector.begin()+3,myvector.end()-2,8);   // myvector: 5 5 5 8 8 8 0 0

    return 0;
}

同样还有一个fill_n函数，与fill函数不同的是，它接收的参数。它接受的三个参数不是范围

 OutputIterator fill_n (OutputIterator first, Size n, const T& val);

first为起始地址，n表示从first开始到后面的n-1个数被赋值成val，如果n的范围超过容器的大小，会出现未定义的行为！

源码如下

template <class OutputIterator, class Size, class T>
OutputIterator fill_n (OutputIterator first, Size n, const T& val)
{
  while (n>0) {
    *first = val;
    ++first; --n;
  }
  return first;     // since C++11
}

使用例子
代码来自cpp官网

#include <bits/stdc++.h>
using namespace std;

int main ()
{
    ios::sync_with_stdio(false);
    std::vector<int> myvector (8,10);        // myvector: 10 10 10 10 10 10 10 10

    std::fill_n (myvector.begin(),4,20);     // myvector: 20 20 20 20 10 10 10 10
    std::fill_n (myvector.begin()+3,3,33);   // myvector: 20 20 20 33 33 33 10 10

    return 0;
}

复制：

copy函数接受三个参数

  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);

first和last表示复制数据的范围，result表示被赋值容器的起始位置，这里被赋值的容器大小至少要和[first,last)长度相同。

源码：

template<class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = *first;
    ++result; ++first;
  }
  return result;
}

使用例子
代码来自cpp官网

#include <bits/stdc++.h>
using namespace std;

int main ()
{
    ios::sync_with_stdio(false);
    int myints[]={10,20,30,40,50,60,70};
    std::vector<int> myvector (7);
    std::copy (myints, myints+7, myvector.begin());

    //书上的例子
    int a1[]={1,2,3,4,5};
    int a2[sizeof(a1)/sizeof(*a1)];//a2与a1一样大小
    auto ret=copy(begin(a1),end(a1),a2);
    //ret返回为a2赋值的结尾
    return 0;
}