c++学习笔记（十一、常用算法）

最新推荐文章于 2024-06-13 11:23:52 发布

酱油师兄

最新推荐文章于 2024-06-13 11:23:52 发布

阅读量2k

点赞数 4

分类专栏： C/C++ 文章标签：查找函数遍历函数排序算法拷贝和替换算术算法

本文链接：https://blog.csdn.net/C1033177205/article/details/104177207

版权

C/C++ 专栏收录该内容

14 篇文章 3 订阅

订阅专栏

这一篇只要是介绍了一些STL的常用算法，查找函数、遍历函数、排序函数、拷贝和替换函数、算术生成函数、集合算法。这些算法应该都是比较常用的，所以就过一遍，其实这篇文件我原创内容不多，都是看着黑马程序员c++的视频，把函数抄出来的，希望黑马程序员那边不要介意，有需要看详细的，可以去看看他们的c++视频，是免费的哈哈哈。

11.1 常用查找函数

/*
    find    算法    查找元素
    @param  beg     容器开始迭代器
    @param  end     容器结束迭代器
    @param  value   查找的元素
    @return  iterator 返回查找元素的位置（迭代器）
*/
iterator find(iterator beg, iterator end, value);

/*
    adjacent_find       算法            查找相邻重复元素
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者谓词（返回bool类型的函数对象）
    @return iterator  返回相邻元素的第一个位置的迭代器（迭代器）
*/
iterator adjacent_find(iterator beg, iterator end, _callback);

/*
    binary_search       算法            二分查找法
    注意：在无序序列中不可用
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  value       查找的元素
    @return  bool       查找返回true 否则false
*/
bool binary_search(iterator beg, iterator end, value);

/*
    find_if       算法            条件查找
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者谓词（返回bool类型的函数对象）
    @return  iterator   返回第一个满足_callback条件的迭代器
*/
iterator find_if(iterator beg, iterator end, _callback);

/*
    count       算法            统计元素出现次数
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  value       需要统计的元素
    @return  int        返回元素个数
*/
int count(iterator beg, iterator end, value);

/*
    count_if       算法            统计元素出现次数
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者谓词（返回bool类型的函数对象）
    @return  int        返回满足_callback的元素个数
*/
int count_if(iterator beg, iterator end, _callback);

例子就不用写了吧

11.2 常用遍历函数

/*
    for_each       遍历算法            遍历容器元素
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者函数对象
    @return  函数对象

    源码：
    template <class _InIt, class _Fn>
    _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func)
*/
_Fn for_each(iterator beg, iterator end, _Fn _callback);

/*
    transform      算法            将指定容器区间元素搬运到另一个容器中
    注意：transform 不会给目标容器分配内存，所以需要我们提前分配好内存（比如vector容器，需要用resize分配内存，而不能使用reserve）
    @param  beg1         源容器开始迭代器
    @param  end1         源容器结束迭代器
    @param  beg2         目标容器开始迭代器
    @param  _callback   回调函数或者函数对象
    @return  返回目标容器的迭代器

    源码：
    template <class _InIt, class _OutIt, class _Fn>
    _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func);
*/
iterator transform(iterator beg1, iterator end1, iterator beg2, _Fn _callback);

这个有点难点，还是写下例子：

Person* show4(Person* p) {
   return p;
}

void main(){
	vector<Person*> vpp;
	vector<Person*> vpp1;
	vpp.push_back(&p1);
	vpp.push_back(&p2);
	vpp.push_back(&p3);
	vpp.push_back(&p4);
	cout << "======================" << endl;
	for_each(vpp.begin(), vpp.end(), mem_fun(&Person::show));
	
	vpp1.resize(vpp.size());    //这是申请空间
	
	transform(vpp.begin(), vpp.end(), vpp1.begin(), show4); //拷贝
	cout << "======================" << endl;
	for_each(vpp1.begin(), vpp1.end(), mem_fun(&Person::show));
}

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

11.3 常用排序算法

/*
    merge      算法      容器元素合并，并存储到另一个容器中
    注意：两个容器必须是有序的，不支持随机访问也可以
    @param  beg1         容器 1 开始迭代器
    @param  end1         容器 1 结束迭代器
    @param  beg2         容器 2 开始迭代器
    @param  end2         容器 2 结束迭代器
    @param  dest         目标容器开始迭代器
    @return  返回目标容器的迭代器

    源码：
    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
*/
iterator merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    sort      算法      容器元素排序
    注意：支持随机访问
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者谓词（返回bool类型的函数对象）
    @return  void

    源码：
    template <class _RanIt, class _Pr>
    _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)
*/
void sort(iterator beg, iterator end, _callback);

/*
    random_shuffle      算法      对指定范围内的元素随机调整次序
    注意：支持随机访问
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @return  void

    源码：
    template <class _RanIt, class _RngFn>
    void random_shuffle(_RanIt _First, _RanIt _Last, _RngFn&& _RngFunc)

    template <class _RanIt>
    void random_shuffle(_RanIt _First, _RanIt _Last)
*/
void random_shuffle(iterator beg, iterator end);

/*
    reverse      算法      反转指定范围内的元素
    注意：支持随机访问
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @return  void

    源码：
*/
void reverse(iterator beg, iterator end);

排序算法比较简单，就不写例子了。

11.4 常用拷贝和替换算法

/*
    copy      算法      将容器内指定范围的元素拷贝到另一个容器中
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  dest        目标容器迭代器
    @return  iterator   目标容器迭代器

    源码：
*/
iterator copy(iterator beg, iterator end, iterator dest);

/*
    replace      算法      将容器内指定范围的旧元素修改成为新元素
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  oldvalue    旧元素
    @param  mewvalue    新元素
    @return  void

    源码：
    template <class _FwdIt, class _Ty>
    _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval)

    不知道为什么要传旧参数，先找到旧参数，然后替换成新参数
*/
void replace(iterator beg, iterator end, oldvalue, mewvalue);

/*
    replace_if      算法      将容器内指定范围满足_callback条件的元素修改成为新元素
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  _callback   回调函数或者谓词（返回bool类型的函数对象）
    @param  mewvalue    新元素
    @return  void

    源码：
    template <class _FwdIt, class _Pr, class _Ty>
    _CONSTEXPR20 void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val)

    _callback  一个回调函数，可以写成大于5的条件
*/
void replace_if(iterator beg, iterator end, _callback, mewvalue);

/*
    swap      算法      互换两个容器的元素
    @param  c1         容器1
    @param  c2         容器2
    @return  void

    源码：
    
*/
void swap(container c1, container c2);

例子也不写了，回调函数还需要看一下别人的。

11.5 常用算术生成算法

#include <numeric>  //包含头文件
/*
    accumulate      算法      计算容器元素累计总和
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  value       算了和之后，如果还要加一个值，就是这个value，如果求合填0
    @return  int       返回和

    源码：
    
*/
int accumulate(iterator beg, iterator end, value);

/*
    fill      算法      向容器中添加元素
    @param  beg         容器开始迭代器
    @param  end         容器结束迭代器
    @param  value       填充元素
    @return  void

    源码：
    
    就是往迭代器中，填充value的值，填充范围是beg-end,就得要申请空间
*/
void fill(iterator beg, iterator end, value);

11.6 常用集合算法

也不是很常用，就是两个集合的交集、并集和差集。

/*
    set_intersection      算法      求两个set集合的交集
    注意：两个集合必须是有序序列
    @param  beg1         容器 1 开始迭代器
    @param  end1         容器 1 结束迭代器
    @param  beg2         容器 2 开始迭代器
    @param  end2         容器 2 结束迭代器
    @param  dest         目标容器开始迭代器
    @return  iterator    目标容器的最后一个元素的迭代器地址

    源码：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_intersection(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)

    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    
*/
iterator set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    set_union      算法      求两个set集合的并集
    注意：两个集合必须是有序序列
    @param  beg1         容器 1 开始迭代器
    @param  end1         容器 1 结束迭代器
    @param  beg2         容器 2 开始迭代器
    @param  end2         容器 2 结束迭代器
    @param  dest         目标容器开始迭代器
    @return  iterator    目标容器的最后一个元素的迭代器地址

    源码：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
    
*/
iterator set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
    set_difference      算法      求两个set集合的差集
    注意：两个集合必须是有序序列
    @param  beg1         容器 1 开始迭代器
    @param  end1         容器 1 结束迭代器
    @param  beg2         容器 2 开始迭代器
    @param  end2         容器 2 结束迭代器
    @param  dest         目标容器开始迭代器
    @return  iterator    目标容器的最后一个元素的迭代器地址

    源码：
    template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
    _CONSTEXPR20 _OutIt set_difference(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) 

    template <class _InIt1, class _InIt2, class _OutIt>
    _CONSTEXPR20 _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    
    beg1 差 beg2 是只有beg1的元素（没有beg2的，也没有beg1和beg2相同的元素）
*/
iterator set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

酱油师兄

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
c++学习笔记（十一、常用算法）

这一篇只要是介绍了一些STL的常用算法，查找函数、遍历函数、排序函数、拷贝和替换函数、算术生成函数、集合算法。这些算法应该都是比较常用的，所以就过一遍，其实这篇文件我原创内容不多，都是看着黑马程序员c++的视频，把函数抄出来的，希望黑马程序员那边不要介意，有需要看详细的，可以去看看他们的c++视频，是免费的哈哈哈。
复制链接

扫一扫