C++ STL常用算法

最新推荐文章于 2023-10-10 09:38:28 发布
最新推荐文章于 2023-10-10 09:38:28 发布
阅读量484 收藏 1
点赞数
分类专栏： c++ 文章标签： C++ STL C++ STL C++算法 C++常用算法
原文链接：https://blog.csdn.net/ClaireSy/article/details/108423061
版权

目录

1. 常用遍历算法

1.1 for_each遍历容器

1.2 transorm 搬运容器到另一个容器中

2. 常用查找算法

2.1 find查找算法

2.2 find_if条件查询

2.3 adjacent_find 查找相邻重复元素.

2.4 binary_search 二分查找 

2.5 count 统计元素个数

2.6 count_if 条件统计

3.排序算法

3.1 sort对容器元素排序

3.2 random_shuffle 随机调整顺序

3.3 merge容器元素合并

3.4 reverse 将容器元素反转

4. 拷贝和替换算法

4.1 copy容器拷贝

4.2 replace 容器元素替换

4.3 replace_if条件替换

4.4 swap容器元素互换

5. 常用算术生成算法

5.1 accumulate容器元素累加和

5.2 fill容器填充

6. 常用集合算法

6.1 set_intersection求容器交集

6.2 set_union 求两个集合的并集

6.3 set_difference求容器差集

  • 算法主要是由头文件<algorithm> <functional> <numeric>组成。

  • <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等

  • <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数

  • <functional>定义了一些模板类,用以声明函数对象。

1. 常用遍历算法

1.1 for_each遍历容器

函数原型：for_each(iterator begin, iterator end, _func);

  • // 遍历算法 遍历容器元素
  • // beg 开始迭代器
  • // end 结束迭代器
  • // _func 函数或者函数对象
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
//普通函数
void print01(int val) 
{
	cout << val << " ";
}
//函数对象
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//for_each算法基本用法
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);
	}

	//遍历算法
	for_each(v.begin(), v.end(), print01);
	cout << endl;

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

int main() {

	test01();

	system("pause");

	return 0;
}

 

1.2 transorm 搬运容器到另一个容器中

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

  • //beg1 源容器开始迭代器
  • //end1 源容器结束迭代器
  • //beg2 目标容器开始迭代器
  • //_func 函数或者函数对象

注意目标容器必须要提前开辟空间

#include<vector>
#include<algorithm>
#include <iostream>
using namespace std;
//常用遍历算法  搬运 transform

class TransForm
{
public:
	int operator()(int val)
	{
		return val;
	}

};

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

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>vTarget; //目标容器

	vTarget.resize(v.size()); // 目标容器需要提前开辟空间

	transform(v.begin(), v.end(), vTarget.begin(), TransForm());

	for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

int main() {

	test01();

	system("pause");

	return 0;
}

2. 常用查找算法

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

 2.1 find查找算法

函数原型：

  • find(iterator beg, iterator end, value);

    // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg 开始迭代器

    // end 结束迭代器

    // value 查找的元素

    vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	//查找容器中是否有 5 这个元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it == v.end()) 
	{
		cout << "没有找到!" << endl;
	}
	else 
	{
		cout << "找到:" << *it << endl;
	}

2.2 find_if条件查询

函数原型：

  • find_if(iterator beg, iterator end, _Pred);

    // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 函数或者谓词（返回bool类型的仿函数）

#include <algorithm>
#include <vector>
#include <string>
#include<iostream>
using namespace std;
//内置数据类型
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}

	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "没有找到!" << endl;
	}
	else {
		cout << "找到大于5的数字:" << *it << endl;
	}
}
int main(){
    test01();
}

2.3 adjacent_find 查找相邻重复元素.

函数原型：

  • adjacent_find(iterator beg, iterator end);

    // 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

    // beg 开始迭代器

    // end 结束迭代器

#include <algorithm>
#include <vector>

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	v.push_back(4);
	v.push_back(3);

	//查找相邻重复元素
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it == v.end()) {
		cout << "找不到!" << endl;
	}
	else {
		cout << "找到相邻重复元素为:" << *it << endl;
	}
}

2.4 binary_search 二分查找 

函数原型：

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

    // 查找指定的元素，查到 返回true 否则false

    // 注意: 在无序序列中不可用

    // beg 开始迭代器

    // end 结束迭代器

    // value 查找的元素

#include <algorithm>
#include <vector>

void test01()
{
	vector<int>v;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//二分查找
	bool ret = binary_search(v.begin(), v.end(),2);
	if (ret)
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
}

 2.5 count 统计元素个数

函数原型：

  • count(iterator beg, iterator end, value);

    // 统计元素出现次数

    // beg 开始迭代器

    // end 结束迭代器

    // value 统计的元素

#include <algorithm>
#include <vector>

//内置数据类型
void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);
	v.push_back(4);

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

	cout << "4的个数为： " << num << endl;
}

//自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(const Person & p)
	{
		if (this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};

void test02()
{
	vector<Person> v;

	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
    
    Person p("诸葛亮",35);

	int num = count(v.begin(), v.end(), p);
	cout << "num = " << num << endl;
}
int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

总结： 统计自定义数据类型时候，需要配合重载 operator==

2.6 count_if 条件统计

函数原型：

  • count_if(iterator beg, iterator end, _Pred);

    // 按条件统计元素出现次数

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 谓词

#include <algorithm>
#include <vector>
#include<iostream>
using namespace std;
class Greater4
{
public:
	bool operator()(int val)
	{
		return val >= 4;
	}
};

//内置数据类型
void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);
	v.push_back(4);

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

	cout << "大于4的个数为： " << num << endl;
}

//自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

class AgeLess35
{
public:
	bool operator()(const Person &p)
	{
		return p.m_Age < 35;
	}
};
void test02()
{
	vector<Person> v;

	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	int num = count_if(v.begin(), v.end(), AgeLess35());
	cout << "小于35岁的个数：" << num << endl;
}


int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

3.排序算法

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

3.1 sort对容器元素排序

函数原型：

  • sort(iterator beg, iterator end, _Pred);

    // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg 开始迭代器

    // end 结束迭代器

    // _Pred 谓词

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
void myPrint(int val)
{
	cout << val << " ";
}

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

	//sort默认从小到大排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	//从大到小排序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

3.2 random_shuffle 随机调整顺序

函数原型：

  • random_shuffle(iterator beg, iterator end);

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

    // beg 开始迭代器

    // end 结束迭代器

  • random_shuffle洗牌算法比较实用，使用时记得加随机数种子

3.3 merge容器元素合并

函数原型：

  • merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

    // 容器元素合并，并存储到另一容器中.

    // 注意: 两个容器必须是有序的

    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器，目标容器必须要提前开辟空间

3.4 reverse 将容器元素反转

函数原型：

  • reverse(iterator beg, iterator end);

    // 反转指定范围的元素

    // beg 开始迭代器

    // end 结束迭代器

4. 拷贝和替换算法

  • copy // 容器内指定范围的元素拷贝到另一容器中
  • replace // 将容器内指定范围的旧元素修改为新元素
  • replace_if // 容器内指定范围满足条件的元素替换为新元素
  • swap // 互换两个容器的元素

4.1 copy容器拷贝

函数原型：

copy(iterator beg, iterator end, iterator dest);

        // 容器内指定范围的元素拷贝到另一容器中

        // beg 开始迭代器

        // end 结束迭代器

        // dest 目标起始迭代器        

        //利用copy算法在拷贝时，目标容器记得提前开辟空间

#include <algorithm>
#include <vector>
#include<iostream>
using namespace std;
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i + 1);
	}
	vector<int> v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());

	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.2 replace 容器元素替换

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

函数原型：

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

    // 将区间内旧元素 替换成 新元素

    // beg 开始迭代器

    // end 结束迭代器

    // oldvalue 旧元素

    // newvalue 新元素

4.3 replace_if条件替换

函数原型：

  • replace_if(iterator beg, iterator end, _pred, newvalue);

    // 按条件替换元素，满足条件的替换成指定元素

    // beg 开始迭代器

    // end 结束迭代器

    // _pred 谓词

    // newvalue 替换的新元素

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

class ReplaceGreater30
{
public:
	bool operator()(int val)
	{
		return val >= 30;
	}

};

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

	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//将容器中大于等于的30 替换成 3000
	cout << "替换后：" << endl;
	replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.4 swap容器元素互换

互换两个容器的元素

函数原型：

  • swap(container c1, container c2);

    // 互换两个容器的元素

    // c1容器1

    // c2容器2

5. 常用算术生成算法

5.1 accumulate容器元素累加和

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

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

        // 计算容器元素累计总和

        // beg 开始迭代器

        // end 结束迭代器

        // value 起始值

5.2 fill容器填充

功能描述：

  • 向容器中填充指定的元素

函数原型：

  • fill(iterator beg, iterator end, value);

    // 向容器中填充元素

    // beg 开始迭代器

    // end 结束迭代器

    // value 填充的值

vector<int> v;

v.resize(10);

//填充 fill(v.begin(), v.end(), 100);

6. 常用集合算法

6.1 set_intersection求容器交集

函数原型：

  • set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

    // 求两个集合的交集

    // 注意:两个集合必须是有序序列

    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器

vector<int> v1;

vector<int> v2;

for (int i = 0; i < 10; i++) {

    v1.push_back(i);

    v2.push_back(i+5);

}

vector<int> vTarget; //取两个里面较小的值给目标容器开辟空间

vTarget.resize(min(v1.size(), v2.size()));
 //返回目标容器的最后一个元素的迭代器地址 
vector<int>::iterator itEnd = set_intersection(v1.begin(),
     v1.end(), v2.begin(), v2.end(), vTarget.begin());

6.2 set_union 求两个集合的并集

        // 注意:两个集合必须是有序序列

        // beg1 容器1开始迭代器
        // end1 容器1结束迭代器
        // beg2 容器2开始迭代器
        // end2 容器2结束迭代器
        // dest 目标容器开始迭代器

总结：

  • 求并集的两个集合必须的有序序列
  • 目标容器开辟空间需要两个容器相加
  • set_union返回值既是并集中最后一个元素的位置

6.3 set_difference求容器差集

功能描述：

  • 求两个集合的差集

函数原型：

  • set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

    // 求两个集合的差集

    // 注意:两个集合必须是有序序列

    // beg1 容器1开始迭代器
    // end1 容器1结束迭代器
    // beg2 容器2开始迭代器
    // end2 容器2结束迭代器
    // dest 目标容器开始迭代器

  • 求差集的两个集合必须的有序序列

  • 目标容器开辟空间需要从两个容器取较大值

dream or nightmare
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
std中稳定排序算法_八大经典排序算法
weixin_36295010的博客
01-30 548
一、插入排序-直接插入排序(Straight Insertion Sort)直接插入排序(Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。#include usi...
C++11标准模板（STL）- 算法（std::swap）
qq_40788199的博客
11-04 1491
交换给定值 1) 交换 a 与 b 。此重载仅若 std::is_move_constructible_v && std::is_move_assignable_v 为 true 才参与重载决议。 (C++17 起)
经典文献阅读之--STD(激光SLAM回环检测算法)
最新发布
lovely_yoshino的博客
10-10 8465
各位也知道，我们在之前的博客中，介绍了很多回环的方法，比如Scan Context，Lris, BoW3D等方法。之前作者也在《》一文中，给到了一些回环检测算法的介绍。最近林博新开源了一个回环检测算法《我们从博主中的实验中发现，确实效果不错，同时相关的代码也已经在上开源了。图1。(a)显示从查询点云中提取的稳定三角形描述符(STD)。(b)显示从历史点云中提取的STD。（c）显示了这两帧点云之间STD匹配的示例。正确匹配的STD描述符由白色框标示，并且通过STD提供的姿态进行点云配准。
C++11标准模板（STL）- 算法 - 堆操作（std::sort_heap）
qq_40788199的博客
12-12 706
转换最大堆 [first, last) 为以升序排序的范围。产生的范围不再拥有堆属性。 函数的第一版本用 operator< 比较元素，第二版本用给定的比较函数 comp 比较。
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
C++常用stl算法.pdf
11-22
这篇文档主要讨论了C++ STL中的一些常用算法，包括函数对象适配器，如`for_each`、`bind`等。让我们深入探讨这些概念。 首先，函数对象在C++中是一个重要的概念，它是一个类，通过重载`()`操作符使得类的对象能够像...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
C++ STL教程pdf
05-10
2. **标准模板**：在C++ STL中，模板被用来定义泛型类（如容器和迭代器）和泛型函数（如算法）。例如，`vector`、`list`、`map`等都是标准模板类，它们可以存储不同类型的数据。模板使代码更加模块化，易于维护和...
STL常用算法
06-18
STL常用算法 七十个 12
std中稳定排序算法_稳定排序算法
weixin_29545475的博客
12-11 266
常用排序算法？稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。冒泡排序算法：比较相邻的元素，按照顺序进行交换，一次遍历后，就会有一个最大（最小）交换至顶端，重复步骤即可。python实现：arr = [54,26,93,17,77,31,44,55,20] ...
C++11标准模板（STL）- 算法 - 数值运算 （std::accumulate）
qq_40788199的博客
12-25 3565
对一个范围内的元素求和。 计算给定值 init 与给定范围 [first, last) 中元素的和。第一版本用 operator+ ，第二版本用二元函数 op 求和元素，均将 std::move 应用到其左侧运算数 (C++20 起)。
Qt std常用算法
pejay23的博客
05-29 1968
QStringList list; list<<"one"<<"two"<<"three"; qDebug()<<list; QVector<QString> vect(3); std::copy(list.begin(),list.end(),vect.begin()); qDebug()<<vect<<endl<<"__________"; /* v.
md5与des算法有何不同_最详细的排序算法讲解！一看就懂！
weixin_39692253的博客
11-23 474
排序算法对大家来说肯定都不陌生吧，作为最基础且最重要的算法之一，在面试中经典排序算法也经常被要求手撕代码。可是排序算法实在是太多了(见下图)，有些名字听起来都莫名其妙的，比如鸡尾酒排序，侏儒排序，煎饼排序等。 当然，这篇文章会为大家讲解众多排序算法中最经典的部分，也是大家最熟悉的几种算法，包括冒泡排序、插入排序、选择排序、归并排序、计数排序、基数排序、桶排序、希尔排序、堆排序。同时也会利用一些手...
std.algorithm 算法--1（2.030）
hqs7636的专栏
06-16 309
6.1 20 点 更新 5.21 19点 更新 5.6 0点 更新 5.2 18点 更新 5.1 23点 更新 std.algorithm Jump to: map reduce fill filter move moveAll moveSome swap Splitter splitter Uniq uniq find BoyerMoo...
STL 算法库algorithm
Worthy_Wang的博客
03-16 425
C++ STL < algorithm > 头文件中的函数 文章目录C++ STL < algorithm > 头文件中的函数@[toc]前言一.for_each二.count_if三.find_if四.unique五.sort 与 std::less std::greater六.remove_if七.move八.copy copy_if九.merge 前言 有了 #in...
C++STL中的常用算法
lyxawdn的博客
03-30 456
概述： 使用算法记得包含头文件等 是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历、复制、修改等 体积很小，只包括几个在序列上面进行简单数学运算的模板函数 定义了一些模板类，用以声明函数对象 一、常用遍历算法 1、for_each： 实现遍历容器： for_each(iterator beg, iterator end, _func); //分别用普通函数与函数对象来作为第三个参数 //普通函数 void print01(int val) { cout << val &lt
C++标准库之算法库
qq_17044529的博客
09-12 7840
目录 1.不修改序列的操作 2.修改序列的操作 3.划分操作 4.排序操作 5.二分搜索操作(在已排序范围上) 6.集合操作(在已排序范围上) 7.堆操作 8.最小/最大操作 9.比较操作 10.排列操作 11.数值运算 1.不修改序列的操作 ^ all_of，any_of和none_of：判断一定范围内，是否全部，存在或不存在元素。 for_each：将一个函数应用于某...
c++stl排序算法
09-01
C++ STL（Standard Template Library）提供了许多排序算法，可以用来对容器中的元素进行排序。以下是一些常用的排序算法： 1. sort()：使用快速排序算法对容器中的元素进行排序。它可以接受两个迭代器作为参数，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值