STL常用算法笔记 -- 黑马程序员

置顶甘-

已于 2024-03-19 12:41:43 修改

阅读量432

点赞数 8

文章标签：算法 c++ STL

于 2024-02-05 20:14:38 首次发布

本文链接：https://blog.csdn.net/weixin_74814064/article/details/136046962

版权

文章目录

一、函数对象
二、谓词
三、内建函数对象
- 1、算术仿函数
- 2、关系仿函数
- 3、逻辑仿函数
四、常用的STL算法
- 1、遍历算法 - for_each
- 2、遍历算法 - transform
- 3、查找算法 - find
- 4、查找算法 - find_if
- 5、查找重复算法 - adjacent_find
- 6、二分查找 - bianry_search
- 7、统计算法 - count
- 8、统计算法 - count_if
- 9、排序算法 - sort
- 10、洗牌算法 - random_shuffle
- 11、排序算法 - merge
- 12、排序算法 - reverse
- 12、拷贝算法 - copy
- 13、替换算法 - replace
- 13、替换算法 - replace_if
- 14、互换算法 - swap
- 15、最大值算法 - max
- 16、最小值算法 - min
五、算术生成算法
- 1、元素总和 - accumulate
- 2、填充元素 - fill
六、集合算法
- 1、交集 - set_intersection
- 2、并集 - union
- 3、差集 - set_difference

一、函数对象

概念:

重载函数调用操作符的类，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质:

函数对象(仿函数)是一个类，不是一个函数

二、谓词

概念:

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词

_InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred)
_InIt _First：为要查找区间的初始位置。const _InIt _Last：为要查找区间的结束位置。_Pr _Pred：为一元谓词，也称仿函数。

如果operator()接受两个参数，那么叫做二元谓词

例如void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)最后
_Pr _Pred 为二元谓词，需要两个参数比较大小

三、内建函数对象

概念：

STL内建了一-些函数对象

分类:

算术仿函数
关系仿函数
逻辑仿函数

用法:

这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件 #include<functional>

1、算术仿函数

仿函数原型:

加法仿函数 template<class T> T plus<T>
减法仿函数 template<class T> T minus<T>
乘法仿函数 template<class T> T multiplies<T>
除法仿函数 template<class T> T divides<T>
取模仿函数 template<class T> T modulus<T>
取反仿函数 template<class T> T negate<T>

	plus<int> p; //加
	cout << p(5, 80) << endl;

	minus<int> m; //减
	cout << m(40, 20) << endl;

	multiplies<double> mul; //乘
	cout << mul(4.1, 5.2) << endl;

	divides<int> d; //除
	cout << d(10, 5) << endl;

	modulus<int> mod;//取模
	cout << mod(5, 4) << endl;

	negate<int> n; //取反
	cout << n(50) << endl;

2、关系仿函数

仿函数原型:

等于 template<class T> bool equal_ to<T>
不等于 template<class T> bool not_ equal_ to<T>
大于 template<class T> bool greater<T>
大于等于 template<class T> bool greater_ equal<T>
小于 template<class T> bool less<T>
小于等于 template<class T> bool less_ equal<T>

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	sort(v.begin(), v.end(), greater<int>());//大到小排序

3、逻辑仿函数

仿函数原型:

逻辑与 template<class T> bool logical_and<T>
逻辑或 template<class T> bool logical_or<T>
逻辑非 template<class T> bool logical_not<T>

四、常用的STL算法

概述:

算法主要是由头文件 <algorithm> <functional> <numeric> 组成。
<algorithm> 是所有STL头文件中最大的一一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等
<numeric> 体积很小，只包括几个在序列上面进行简单数学运算的模板函数
<functional> 定义了一些模板类，用以声明函数对象。

1、遍历算法 - for_each

功能描述:

实现遍历容器

函数原型:

for_each(iterator beg, iterator end, _func);
//遍历算法遍历容器元素，beg开始迭代器，end结束迭代器，_func函数或者函数对象

	class func
	{
	public:
		void operator()(int val)
		{
			cout << val << " ";
		}
	};

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	for_each(v.begin(), v.end(), func());

2、遍历算法 - transform

功能描述:

搬运容器到另一个容器中，对数据可以进行逻辑运算

函数原型:

transform( iterator beg1, iterator end1, iterator beg2, _func);
//beg1容器开始迭代器，end1容器结束迭代器，beg2目标容器开始迭代器，_func函数或者函数对象

class tranFunc
{
public:
	int operator()(int val)
	{
		//对数据可以进行逻辑运算
		return val * 2;
	}
};

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	vector<int> v2;
	v2.resize(v.size());//指定v2的空间大小

	transform(v.begin(), v.end(), v2.begin(), tranFunc());

	for_each(v2.begin(), v2.end(), func());

3、查找算法 - find

功能描述:

查找指定元素,找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型:

find(iterator beg, iterator end, value);
//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg开始迭代器，end结束迭代器，value查找的元素

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	vector<int>::iterator it = find(v.begin(), v.end(), 5);

	if (it != v.end())
		cout << "查找成功" << endl;
	else
		cout << "查找失败" << endl;

4、查找算法 - find_if

功能描述:

按条件查找元素

函数原型:

find_if(iterator beg, iterator end, _Pred);
//按值查找元素,找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg开始迭代器，end结束迭代器，_Pred函数或者谓词(返回bool类型的仿函数)

class Find
{
public:
	bool operator()(int val)
	{
		return val > 25;
	}
};

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(5);
	v.push_back(18);

	vector<int>::iterator it = find_if(v.begin(), v.end(), Find());
	if (it != v.end())
		cout << "查找成功" << " " << *it << endl;
	else
		cout << "查找失败" << endl;

5、查找重复算法 - adjacent_find

功能描述:

查找相邻重复元素

函数原型:

adjacent_find(iterator beg, iterator end);
//查找相邻重复元素,返回相邻元素的第一个位置的迭代器
// beg开始迭代器，end结束迭代器

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());

	if (pos != v.end())
		cout << "查找相邻元素成功："  << *pos << endl;
	else
		cout << "查找相邻元素失败" << endl;

6、二分查找 - bianry_search

功能描述:

查找指定元素是否存在

函数原型:

bool binary_search(iterator beg, iterator end, value);
//查找指定的元素，查到返回true否则false，注意:在无序序列中不可用
// beg开始迭代器，end结束迭代器，value查找的元素

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	sort(v.begin(), v.end());//排序

	bool ret = binary_search(v.begin(), v.end(), 23);//二分查找 
	
	if (ret == 1)
		cout << "查找成功" << endl;
	else
		cout << "查找失败" << endl;

7、统计算法 - count

功能描述:

统计元素个数

函数原型:

count(iterator beg, iterator end, value);
//统计元素出现次数,beg开始迭代器,end结束迭代器,value统计的元素

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	int num = count(v.begin(), v.end(), 10);

8、统计算法 - count_if

功能描述:

按条件统计元素个数

函数原型:

count_if(iterator beg, iterator end, _ Pred);
//按条件统计元素出现次数,beg开始迭代器,end结束迭代器,_Pred谓词

class greater_20
{
public:
	bool operator()(int val)
	{
		return val > 20;
	}
};

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	int num = count_if(v.begin(), v.end(), greater_20());

9、排序算法 - sort

第一种sort重载

void sort(const _RanIt _First, const _RanIt _Last)

两个参数为要排序的区间

第二种sort重载

void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)

最后 _Pr _Pred 为谓词，也是仿函数

class compare
{
public:
	bool operator()(int v1, int v2)
	{
		return v1 > v2;
	}
};

void test01()
{
	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(40);
	v.push_back(18);

	cout << "------- 排序前 -------" << endl;
	printVector(v);//遍历容器
.
	sort(v.begin(), v.end(), compare());
	cout << "------- 排序后 -------" << endl;
	printVector(v);//遍历容器
}

10、洗牌算法 - random_shuffle

功能描述:

洗牌指定范围内的元素随机调整次序

函数原型:

random_shuffle(iterator beg, iterator end);
//指定范围内的元素随机调整次序，beg开始迭代器，end结束迭代器

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(40);
	v.push_back(18);

	sort(v.begin(), v.end());

	for_each(v.begin(), v.end(), func());
	cout << endl;

	random_shuffle(v.begin(), v.end());

	for_each(v.begin(), v.end(), func());
	cout << endl;

11、排序算法 - merge

功能描述:

两个容器元素合并，并存储到另一容器中

函数原型:

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//容器元素合并，并存储到另一容器中，注意:两个容器必须是有序的
// beg1容器1开始迭代器，end1容器1结束迭代器，beg2容器2开始迭代器，end2容器2结束迭代器，dest目标容器开始迭代器

	vector<int> v1;
	v1.push_back(1);
	v1.push_back(3);
	v1.push_back(5);

	vector<int> v2;
	v2.push_back(2);
	v2.push_back(4);
	v2.push_back(6);

	vector<int> dest;
	dest.resize(v1.size() + v2.size());

	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), dest.begin());

	for_each(dest.begin(), dest.end(), func());

12、排序算法 - reverse

功能描述:

将容器内元素进行反转

函数原型:

reverse(iterator beg, iterator end);
//反转指定范围的元素，beg开始迭代器，end结束迭代器

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	for_each(v.begin(), v.end(), func());
	cout << endl;

	reverse(v.begin(), v.end());

	for_each(v.begin(), v.end(), func());
	cout << endl;

12、拷贝算法 - copy

功能描述:

容器内指定范围的元素拷贝到另一容器中(不太推荐使用)

函数原型:

copy(iterator beg， iterator end, iterator dest);
//按值查找元素,找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg开始迭代器, end结束迭代器, dest目标起始迭代器

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	vector<int> v2;
	v2.resize(v.size());

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

	for_each(v2.begin(), v2.end(), func());

13、替换算法 - replace

功能描述:

将容器内指定范围的旧元素修改为新元素

函数原型:

replace(iterator beg, iterator end, oldvalue, newvalue);
//将区间内旧元素替换成新元素
// beg开始迭代器，end结束迭代器，oldvalue旧元素，newvalue新元素

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	for_each(v.begin(), v.end(), func());
	cout << endl;

	replace(v.begin(), v.end(), 10, 100);

	for_each(v.begin(), v.end(), func());
	cout << endl;

13、替换算法 - replace_if

功能描述:

将区间内满足条件的元素，替换成指定元素

函数原型:

replace_if(iterator beg, iterator end, _ pred, newvalue);
//按条件替换元素，满足条件的替换成指定元素
// beg开始迭代器, end结束迭代器, _pred谓词, newvalue替换的新元素

class Less40
{
public:
	bool operator()(int val)
	{
		return val < 40;
	}
};

	vector<int> v;
	v.push_back(20);
	v.push_back(10);
	v.push_back(10);
	v.push_back(50);
	v.push_back(23);
	v.push_back(51);
	v.push_back(18);

	for_each(v.begin(), v.end(), func());
	cout << endl;

	replace_if(v.begin(), v.end(), Less40(), 70);

	for_each(v.begin(), v.end(), func());
	cout << endl;

14、互换算法 - swap

功能描述:

互换两个容器的元素

函数原型:

swap(container C1，container c2);
//互换两个容器的元素, C1容器1, c2容器2

	vector<int> v1;
	v1.push_back(1);
	v1.push_back(3);
	v1.push_back(5);

	vector<int> v2;
	v2.push_back(2);
	v2.push_back(4);
	v2.push_back(6);

	swap(v1, v2);

	for_each(v1.begin(), v1.end(), func());
	cout << endl;
	for_each(v2.begin(), v2.end(), func());
	cout << endl;

15、最大值算法 - max

函数原型:

max(v1，v2);
//返回最大值的数值

	int v1 = 20;
	int v2 = 50;
	int num = max(v1, v2);
	cout << num << endl;

16、最小值算法 - min

函数原型:

min(v1，v2);
//返回最小值的数值

	int v1 = 20;
	int v2 = 50;
	int num = min(v1, v2);
	cout << num << endl;

五、算术生成算法

注意:

算术生成算法属于小型算法，便用时包含的头文件为 #include <numeric>

算法简介:

accumulate //计算容器元素累计总和
fill //向容器中添加元素

1、元素总和 - accumulate

功能:

计算区间内容器元素累计总和

**函数原型: **

accumulate(iterator beg, iterator end, value);
//计算容器元素累计总和，beg开始迭代器，end结束迭代器，value起始的累加值

	int num = accumulate(v.begin(), v.end(), 0);
	cout << num << endl;

2、填充元素 - fill

功能:

向容器中的区间填充元素

**函数原型: **

fill(iterator beg, iterator end, value);
//向容器中的区间填充元素，beg开始迭代器，end结束迭代器，valuer填充的值

	vector<int> v;
	v.resize(10);
	fill(v.begin(), v.end(), 10);

六、集合算法

算法简介:

set_intersection //求两个容器的交集
set_union //求两个容器的并集
set_difference //求两个容器的差集

1、交集 - set_intersection

函数原型:

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//求两个集合的交集，返回值是交集最后容器的迭代器的下一个
注意:两个集合必须是有序序列
beg1容器1开始迭代器，end1容器1结束迭代器，beg2容器2开始迭代器，end2容器2结束迭代器，dest目标容器开始迭代器

	v1.push_back(8);
	v1.push_back(4);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(6);
	v1.push_back(7);
	v1.push_back(11);

	v2.push_back(3);
	v2.push_back(2);
	v2.push_back(1);
	v2.push_back(7);
	v2.push_back(9);
	v2.push_back(10);

	sort(v1.begin(), v1.end());
	sort(v2.begin(), v2.end());
	
	//提前指定vTarget的容器大小
	vTarget.resize(min(v1.size(), v2.size()));

	//交集获取
	vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget1.begin(), itEnd1, func());
	cout << endl;
	for_each(vTarget2.begin(), itEnd2, func());
	cout << endl;

2、并集 - union

函数原型:

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//求两个集合的并集，返回值是并集集最后容器的迭代器的下一个
注意:两个集合必须是有序序列
beg1容器1开始迭代器，end1容器1结束迭代器，beg2容器2开始迭代器，end2容器2结束迭代器，dest目标容器开始迭代器

	//提前指定vTarget的容器大小
	vTarget.resize(v1.size() + v2.size());

	//交集获取
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

3、差集 - set_difference

函数原型:

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//求v1对v2差集，返回值是v1差集最后容器的迭代器的下一个
注意:两个集合必须是有序序列
beg1容器1开始迭代器，end1容器1结束迭代器，beg2容器2开始迭代器，end2容器2结束迭代器，dest目标容器开始迭代器
求v1对v2差集，求v2对v2差集，不一样

	//提前开辟空间
	vTarget1.resize(max(v1.size(), v2.size()));
	vTarget2.resize(max(v1.size(), v2.size()));

	//v1对v2的获取
	vector<int>::iterator itEnd1 = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget1.begin());

	//v2对v1的获取
	vector<int>::iterator itEnd2 = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget2.begin());