【万字总结篇】C++STL常用算法详解（错等年系列）

2024-11-22 来源：个人技术集锦

写在前面

以下是正文部分，若有笔误，还请大佬批评指出。

STL常用算法

C++STL中的内置算法主要在头文件<algorithm>、<functional>、<numeric>中

<algorithm>是所有STL头文件中最大的一个，也是包含算法最多，最常用的一个头文件，其中包含比较、交换、查找、遍历、复制、修改等算法
<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数
<functional>定义了一些模板类，用以声明函数对象(仿函数)

注意：本文除了最后的两个算术生成算法在头文件#include<numeric>中以外，其余算法都在头文件#include<algorithm>中

下面将详细介绍一些常用的内置算法，以及会用一些简单的实例帮助大家理解其如何使用。

最大值/最小值

我们先来看两个非常简单并且使用起来非常方便算法

max(a,b)返回a,b中较大的数
min(a,b) 返回a,b中较小的数

注意：

使用这两个函数时，不能使用与其同名的变量(max、min)，比如 max = max(a, b)、min = min(min, b)等。
这两个算法只能比较两个数的大小，如果想比较两个以上数的大小可以嵌套使用，比如求三个数中的最大值m = max(a, max(b, c))

示例：

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	int arr[10] = { 5,8,2,4,6,9,7,0,1,3 };
	int m1=arr[0];
	int m2 = arr[0];
	for (int i = 0; i < 10; ++i) {
		m1 = max(m1, arr[i]);
		m2 = min(m2, arr[i]);
	}
	cout << "最大值为: " << m1 
		 << "\n最小值为: " << m2 << endl;
}

输出如下：

最大值为: 9
最小值为: 0

头文件基本就是例子中那几个，此后的例子中如果没有特殊的头文件需要包含，就省去这一部分了

常用遍历算法

for_each

功能： 遍历容器，进行某种自定义操作。
这个自定义操作就是自己写的一个函数，具体你想干啥自己决定。

函数原型：
for_each(iterator beg,iterator end,_func); 遍历容器

第一个参数beg可以传入容器的起始迭代器，也可以传入数组内第一个元素的地址
第二个参数end可以传入容器的结束迭代器，或者传入数组最后一个元素的下一个位置的地址
最后一个参数_func可以传入一个函数或者函数对象

transform

功能： 按照某种自定义规则搬运容器(或数组)内元素到另一个容器(或数组)中。

函数原型：
transform(iterator beg1,iterator end1,iterator beg2,_func);

beg1传入原容器的起始迭代器，或数组的首地址
end1传入原容器的结束迭代器，或者数组最后一个元素的下一个位置的地址
beg2传入目标容器的起始迭代器，或者目标数组的首地址
_func传入搬运规则函数或函数对象

下面同过一个简单的例子，练习一下这两种遍历算法的使用：

void printArr(int val)//自定义操作：打印
{
	cout << val << " ";
}
int targetArr(int val)//搬运规则函数，在原数据基础上加100
{
	return val + 100;
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };//原数组
	int target[15];//目标数组,目标数组的长度必须不小于原数组
	transform(arr, arr + 10, target, targetArr);
	cout << "原数组打印：";
	for_each(arr, arr + 10, printArr);
	cout << "\n目标数组打印：";
	for_each(target, target + 10, printArr);
}

输出如下：

原数组打印：0 1 2 3 4 5 6 7 8 9
目标数组打印：100 101 102 103 104 105 106 107 108 109

常用查找算法

简介：

find查找元素
find_if按条件查找元素
adjacent_find 查找相邻重复元素
binary_find二分查找法查找元素
count统计元素个数
count_if按条件统计元素个数

find

功能： 按值查找元素

函数原型：

find(iterator beg,iterator end,value);

beg起始迭代器
end结束迭代器
value是要查找的元素，如果其是自定义数据类型，如类的对象、结构体类型的元素,查找时需要重载==运算符
找到返回指定位置的迭代器，找不到返回结束迭代器

下面通过两个例子练习find的使用

对于内置数据类型的使用：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i) {
		v.push_back(i);
	}
	auto it = find(v.begin(), v.end(), 5);//查找元素5
	if (it != v.end()) {
		cout << "找到元素" << *it << endl;
	}
	else {
		cout << "未找到元素";
	}
}

输出如下：

找到元素5

对于自定义数据类型的使用：

class Person
{
public:
	string m_name;
	int m_age;
	Person(string name,int age):m_name(name),m_age(age){}
	//重载==运算符,否则find不知道按什么规则比较
	bool operator==(const Person& p)
	{
		if (m_name == p.m_name && m_age == p.m_age) {
			return true;
		}
		return false;
	}
};
int main()
{
	vector<Person> v;
	v.push_back(Person("张三", 20));
	v.push_back(Person("李四", 25));
	v.push_back(Person("王五", 30));
	v.push_back(Person("赵六", 40));

	Person p("王五",30);

	auto it = find(v.begin(), v.end(), p);//查找元素5
	if (it != v.end()) {
		cout << "找到此人:" << it->m_name << it->m_age << endl;
	}
	else {
		cout << "未找到此人";
	}
}

输入如下：

找到此人:王五30

find_if

功能： 按指定规则查找元素

函数原型：

find_if(iterator beg,iterator end,_Pred);

beg起始迭代器
end结束迭代器
_Pred称为谓词(返回值是bool类型的函数或仿函数称为谓词),在这里用做查找规则。 谓词这个概念很重要，此后会经常见到
找到返回指定位置的迭代器，找不到返回结束迭代器

示例：

bool greaterFive(int val)//查找规则
{
	return val > 5;
}
int main()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i) {
		v.push_back(i);
	}
	auto it = find_if(v.begin(), v.end(), greaterFive);
	if (it != v.end()) {
		cout << "找到大于5的元素：" << *it << endl;
	}
	else {
		cout << "未找到" << endl;
	}
}

输出如下：

找到大于5的元素：6

adjacent_find

功能： 查找相邻且重复的元素

函数原型：

adjacent_find(iterator beg,iterator end);

beg起始迭代器
end结束迭代器
找到返回相邻元素第一个元素位置的迭代器，没找到返回容器结束迭代器

示例：

int main()
{
	vector<int> v;
	v.push_back(2);
	v.push_back(5);
	v.push_back(2);
	v.push_back(3);
	v.push_back(3);
	auto it = adjacent_find(v.begin(), v.end());
	if (it != v.end()) {
		cout << "相邻重复的元素为：" << *it << endl;
	}
	else {
		cout << "不存在相邻重复的元素" << endl;
	}
}

输出如下：

相邻重复的元素为：3

binary_find

功能： 查找指定元素value，找到返回true，否则返回false

特点：

查找速度比一般查找算法快的多，因为一般查找算法的时间复杂度为O(n),而二分查找算法的时间复杂度为O(log(n))
但二分查找也有局限性，它不能用于查找无序序列，也就是说只能利用二分查找查升序排序或降序排序序列中指定的元素

函数原型：

bool binary_search(iterator beg,iterator end,value);

beg起始迭代器
end结束迭代器
只能在有序序列中使用，如果用于无序序列，函数返回的结果将不准确

示例：

int main()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i) {
		v.push_back(i);
	}
	bool flag = binary_search(v.begin(), v.end(), 5);
	if (flag == 1) {
		cout << "找到指定元素" << endl;
	}
	else {
		cout << "未找到" << endl;
	}
}

输出如下：

找到指定元素

count

功能： 统计相同元素出现次数

函数原型：
count(iterator beg,iterator end,value);

统计元素value的个数
beg起始迭代器
end结束迭代器

示例：

我们重点看一下count在自定义数据类型中的使用

class Person
{
public:
	string m_name;
	int m_age;
	Person(string name,int age):m_name(name),m_age(age) {}
	bool operator==(const Person& p)//重载==，作为统计元素规则
	{
		if (m_age == p.m_age) {
			return true;//统计年龄相同的元素
		}
		return false;
	}
};
int main()
{
	vector<Person> v;
	v.push_back(Person("张三", 30));
	v.push_back(Person("李四", 25));
	v.push_back(Person("王五", 35));
	v.push_back(Person("赵六", 25));
	v.push_back(Person("熊大", 25));
	v.push_back(Person("熊二", 20));

	Person p("光头强", 25);
	int num = count(v.begin(), v.end(), p);
	cout << "年龄为25的生物的个数：" << num << endl;
}

输出如下：

年龄为25的生物的个数：3

count_if

功能： 按照指定条件统计元素个数

函数原型：

count_if(iteraotr beg,iterator end,_Pred);

beg起始迭代器
end结束迭代器
_Pred 谓词，在这里用作统计的条件

示例：

bool greater5(int val)
{
	return val > 5;
}
int main()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i) {
		v.push_back(i);
	}
	int num = count_if(v.begin(), v.end(), greater5);
	cout << "大于5的元素的个数为：" << num << endl;
}

输出如下：

大于5的元素的个数为：4

常用排序算法

简介：

sort 对容器内元素进行排序
random_shuffle 对指定范围内元素随机调整次序
merge 容器元素合并，并存储到另一容器中
reverse 反转指定范围的元素

sort

功能： 对容器或数组内元素进行排序

特点：

sort是C++STL中最常用的算法了，没有之一！
sort排序是最快的排序，时间复杂度O(n*log(n))，因为其内部主要由快速排序+插入排序+堆排序实现的。
当排序的序列数据量大时采用快排算法，分段归并排序。一旦分段后的数据量小于某个门槛（16），为避免快排的递归调用带来过大的额外负荷，就改用插入排序。如果递归层次过深，还会改用堆排序。

函数原型：

sort(iterator beg,iterator end,_Pred);

默认对容器内元素升序排序(从小到大)
beg起始迭代器
end结束迭代器
_Pred 谓词，可以不填这个参数(默认升序排序)，如果想按照其他规则排序，如降序排序，这个参数就必须填入
这个算法只有随机存取迭代器可以使用，如普通数组、vector容器、deque容器等等

下面的一个例子将会把前面的算法for_each、transform和sort结合在一起使用

void myPrint(int val)
{
	cout << val << " ";
}
int targetVector(int val)
{
	return val;
}
bool myComepare(int v1,int v2)
{
	return v1 > v2;
}
int main()
{
	int a[10] = { 1,4,7,2,5,8,3,6,9 };//乱序数组
	vector<int> v(10);
	transform(a, a + 10, v.begin(), targetVector);

	cout << "排序前打印数组a: ";
	for_each(a, a + 10, myPrint);
	cout << "\n排序前打印容器v: ";
	for_each(v.begin(), v.end(), myPrint);

	sort(a, a + 10);//默认升序排序
	cout << "\n升序排序后打印数组a: ";
	for_each(a, a + 10, myPrint);

	sort(v.begin(), v.end(), myComepare);//降序排序
	cout << "\n降序排序后打印容器v: ";
	for_each(v.begin(), v.end(), myPrint);
}

输出如下：

排序前打印数组a: 1 4 7 2 5 8 3 6 9 0
排序前打印容器v: 1 4 7 2 5 8 3 6 9 0
升序排序后打印数组a: 0 1 2 3 4 5 6 7 8 9
降序排序后打印容器v: 9 8 7 6 5 4 3 2 1 0

random_shuffle

功能： 指定范围内元素随机调整次序

函数原型：

random_shuffle(iterator beg,iterator end);

beg起始迭代器
end结束迭代器
指定范围[beg,end)内元素随机打乱

注意： 在使用random_shuffle之前最好先撒下随机数种子srand((unsigned)time(NULL))，否则每次随机的结果都是一样的。srand函数在头文件#include<ctime>中。

示例：

void myPrint(int val)
{
	cout << val << " ";
}
int main()
{
	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	srand((unsigned)time(NULL));//随机数种子
	random_shuffle(a, a + 10);
	cout << "随机打乱后：";
	for_each(a, a + 10, myPrint);
}

打印如下(每个人打印的结果可能不同，因为是随机打乱的)：

随机打乱后：0 5 4 6 7 1 8 3 9 2

merge

功能： 将两个有序的容器合并到另一个目标容器中，合并后该目标容器仍然有序

函数原型：

merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator target_beg);

beg1第一个容器或数组起始迭代器
end1第一个容器或数组结束迭代器
beg2第一个容器或数组起始迭代器
end2第一个容器或数组结束迭代器
target_beg目标容器或数组起始迭代器

注意：

两个容器必须是有序的并且是同一种顺序，不能一个升序一个降序
目标容器的大小必须提前指定，并且其大小不小于合并的那两个容器的大小之和

示例：

void myPrint(int val)
{
	cout << val << " ";
}
int main()
{
	vector<int> v;
	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	
	for (int i = 0; i < 10; ++i) {
		v.push_back(i + 5);
	}
	vector<int> target(10 + v.size());
	cout << "打印a: ";
	for_each(a,a+10, myPrint);
	cout << "\n打印打印v2: ";
	for_each(v.begin(), v.end(), myPrint);

	merge(a, a + 10, v.begin(), v.end(), target.begin());
	cout << "\n打印合并后容器target: ";
	for_each(target.begin(), target.end(), myPrint);
}

打印如下：

打印a: 0 1 2 3 4 5 6 7 8 9
打印打印v2: 5 6 7 8 9 10 11 12 13 14
打印合并后容器target: 0 1 2 3 4 5 5 6 6 7 7 8 8 9 9 10 11 12 13 14

reverse

功能： 将容器内元素进行反转

函数原型：

reverse(iterator beg,iterator end);

beg起始迭代器
end结束迭代器

示例：

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	reverse(arr, arr + 10);
	cout << "反转后输出：";
	for (int i = 0; i < 10; ++i) {
		cout << arr[i] << " ";
	}
}

输出如下：

反转后输出：9 8 7 6 5 4 3 2 1 0

常用的替换算法

简介：

swap 交换两个容器的元素，或者仅仅交换两个元素
replace 将容器内指定范围的旧元素替换为新元素
replace_if 按条件将替换元素，满足条件的替换成指定元素

swap

功能： 交换两个容器内的元素，或者仅仅交换两个元素

函数原型：

swap(container c1,container c2);

c1容器1或元素1
c2容器2或元素2

注意： c1和c2必须是同种类型的容器或元素，否则换不了，编译器报错。

示例：

void myPrint(int val)
{
	cout << val << " ";
}
int main()
{
	int a=1, b=2;
	vector<int> v1,v2;
	for (int i = 0; i < 10; ++i) {
		v1.push_back(i);     //v1: 0,1,2,3,4,5,6,7,8,9
		v2.push_back(9 - i); //v2: 9,8,7,6,5,4,3,2,1,0
	}
	swap(a, b);
	cout << "a = " << a << "， b = " << b << endl;
	swap(v1, v2);
	cout << "输出v1: ";
	for_each(v1.begin(), v1.end(), myPrint);
	cout << "\n输出v2: ";
	for_each(v2.begin(), v2.end(), myPrint);
}

输出如下：

a = 2， b = 1
输出v1: 9 8 7 6 5 4 3 2 1 0
输出v2: 0 1 2 3 4 5 6 7 8 9

replace

功能： 将容器内指定范围的旧元素替换为新元素

函数原型：

replace(iterator beg,iterator end,oldvalue,newvalue);

beg起始迭代器
end结束迭代器
将容器[beg,end)内元素oldvalue全部换成newvalue

示例：

int main()
{
	int arr[10] = { 6,3,1,4,8,6,6,7,6,5 };
	replace(arr + 1, arr + 10, 6, 60);
	cout << "替换后：";
	for (int i = 0; i < 10; ++i) {
		cout << arr[i] << " ";
	}
}

输入如下：

替换后：6 3 1 4 8 60 60 7 60 5

replace_if

功能： 按条件将替换元素，满足条件的替换成指定元素

函数原型：

replace_if(iterator beg,iterator end,_Pred,newvalue);

beg起始迭代器
end结束迭代器
_Pred是谓词，将满足谓词条件的元素替换成newvalue

示例：

bool lessFive(int val)//谓词，条件是小于5的数
{
	return val < 5;
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	replace_if(arr, arr + 10, lessFive, 0);
	cout << "替换后：";
	for (int i = 0; i < 10; ++i) {
		cout << arr[i] << " ";
	}
}

输出如下：

替换后：0 0 0 0 0 5 6 7 8 9

常用集合算法

简介：

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

set_intersection

功能： 求两个容器内元素的交集，并把这个交集传给另一个容器

函数原型：

set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator target_beg)

beg1第一个容器起始迭代器
end1第一个容器结束迭代器
beg2第一个容器起始迭代器
end2第一个容器结束迭代器
target_beg目标容器的起始迭代器
函数返回值为目标容器最后一个元素的下一个地址处的迭代器

注意：求交集的两个容器必须是有序序列，而且同序（同升或同降），否则报错。

示例：

int main()
{
	vector<int> v1, v2;
	for (int i = 0; i < 10; ++i) {
		v1.push_back(i);//v1: 0,1,2,3,4,5,6,7,8,9
		v2.push_back(i + 5);      //v2: 5,6,7,8,9,10,11,12,13,14
	}
	vector<int> target;
	//设置目标容器大小
	target.resize(min(v1.size(), v2.size()));

	auto target_end = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());
	cout << "打印存储交集的目标容器：";
	for (auto it = target.begin(); it != target_end; ++it) {
		cout << *it << " ";
	}
}

输出如下：

打印存储交集的目标容器：5 6 7 8 9

set_ union

功能： 求两个容器内元素的并集，并把这个并集传给另一个容器

函数原型：

set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator target_beg)

beg1第一个容器起始迭代器
end1第一个容器结束迭代器
beg2第一个容器起始迭代器
end2第一个容器结束迭代器
target_beg目标容器的起始迭代器
函数返回值为目标容器最后一个元素的下一个地址处的迭代器

注意：求并集的两个容器必须是有序序列，而且同序（同升或同降），否则报错。

示例：

int main()
{
	vector<int> v1, v2;
	for (int i = 0; i < 10; ++i) {
		v1.push_back(i);//v1: 0,1,2,3,4,5,6,7,8,9
		v2.push_back(i+5);        //v2: 5,6,7,8,9,10,11,12,13,14
	}
	vector<int> target;
	//设置目标容器大小
	target.resize(v1.size()+ v2.size());

	auto target_end = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());
	cout << "打印存储并集的目标容器：";
	for (auto it = target.begin(); it != target_end; ++it) {
		cout << *it << " ";
	}
}

输出如下：

打印存储并集的目标容器：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

set_ difference

功能： 求两个容器内元素的差集，并把这个差集传给另一个容器
所谓差集：容器v1相对于v2的差集是，v1内元素去除v1和v2交集部分所剩余的元素

函数原型：

set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator target_beg)

beg1第一个容器起始迭代器
end1第一个容器结束迭代器
beg2第一个容器起始迭代器
end2第一个容器结束迭代器
target_beg目标容器的起始迭代器
函数返回值为目标容器最后一个元素的下一个地址处的迭代器

注意：求并集的两个容器必须是有序序列，而且同序（同升或同降），否则报错。

示例：

int main()
{
	vector<int> v1, v2;
	for (int i = 0; i < 10; ++i) {
		v1.push_back(i);//v1: 0,1,2,3,4,5,6,7,8,9
		v2.push_back(i + 5);      //v2: 5,6,7,8,9,10,11,12,13,14
	}
	vector<int> target;
	//设置目标容器大小
	target.resize(max(v1.size(), v2.size()));

	auto target_end = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());
	cout << "打印v1和v2的差集：";
	for (auto it = target.begin(); it != target_end; ++it) {
		cout << *it << " ";
	}
	target_end = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), target.begin());
	cout << "\n打印v2和v1的差集：";
	for (auto it = target.begin(); it != target_end; ++it) {
		cout << *it << " ";
	}
}

输出如下：

打印v1和v2的差集：0 1 2 3 4
打印v2和v1的差集：10 11 12 13 14

常用的算术生成算法

注意：本文之前介绍的所有算法都在头文件#include<algorithm>中，现在将介绍两个在#include<numeric>中的算法

简介：

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

accumulate

功能： 计算容器内元素累计总和

函数原型：

accumulate(iterator beg,iterator end,value);

beg起始迭代器
end结束迭代器
value是起始值，如果不需要把它设为0
函数返回容器内元素累计总和

#include<iostream>
#include<vector>
#include<numeric>
using namespace std;
int main()
{
	vector<int> v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}
	int sum = accumulate(v.begin(), v.end(), 0);
	cout << "容器内元素和为：" << sum << endl;
}

输出如下：

容器内元素和为：5050

fill

功能： 向容器中填充指定元素

函数原型：

fill(iterator beg,iterator end,value);

beg起始迭代器
end结束迭代器
向容器中填充value

示例：

#include<iostream>
#include<vector>
#include<numeric>
using namespace std;
int main()
{
	vector<int> v(10);
	fill(v.begin(), v.end(), 1);
	for (int i = 0; i < 10; ++i) {
		cout << v[i] << " ";
	}
}

输出如下：

1 1 1 1 1 1 1 1 1 1

结束语

本篇到此结束，共一万两千多字，你的点赞、评论、关注、收藏都是对我最大的支持，谢谢啦！(悄咪咪说一声，本篇可能是C站最详细的C++STL常用算法总结哦)。

显示全文

全部栏目

【万字总结篇】C++STL常用算法详解（错等年系列）

写在前面

STL常用算法

最大值/最小值

常用遍历算法

for_each

transform

常用查找算法

find

find_if

adjacent_find

binary_find

count

count_if

常用排序算法

sort

random_shuffle

merge

reverse

常用的替换算法

swap

replace

replace_if

常用集合算法

set_intersection

set_ union

set_ difference

常用的算术生成算法

accumulate

fill

结束语