【STL】常见遍历算法、查找算法、排序算法

最新推荐文章于 2024-07-24 14:54:00 发布
最新推荐文章于 2024-07-24 14:54:00 发布
阅读量768 收藏 6
点赞数 1
分类专栏： C++核心语法 文章标签： 算法 c++ 排序算法 STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59702185/article/details/126797442
版权

文章目录

概述

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

1. 常用遍历算法

算法原型：

for_each //遍历容器
transform //搬运容器到另一个容器中

1.1 for_each

功能描述：

  • 实现容器的遍历

函数原型：

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

示例：

//普通函数
void print01(int val)
{
	cout << val << " ";
}

//函数对象	仿函数
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i)
	{
		v.push_back(i + 1);
	}
	//遍历
	for_each(v.begin(), v.end(), print01);
	cout << endl;

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

1.2 transform

功能描述：

  • 搬运容器到另一个容器中

函数原型：

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

示例：

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

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

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

	vector<int> target;//目标容器
	target.resize(v.size());//切记提前开辟好空间
	transform(v.begin(), v.end(), target.begin(), TransForm());
	for_each(target.begin(), target.end(), print());
	cout << endl;
}

注意：搬运的目标容器必须提前开辟空间，否则无法正常搬运

2. 常用查找算法

算法原型：

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

2.1 find

功能描述：

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

函数原型：

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

示例：

//内置数据类型
void test01()
{
	vector<int> v;
	for (int i = 0; i < 10; ++i)
	{
		v.push_back(i + 1);
	}
	//查找容器中是否有元素6
	vector<int>::iterator pos = find(v.begin(), v.end(), 6);
	if (pos == v.end()) cout << "没有找到" << endl;
	else cout << "找到了：" << *pos << endl;
}

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

void test02()
{
	vector<Person> v;
	Person p1("张三", 18);
	Person p2("李四", 20);
	Person p3("王五", 25);
	Person p4("老六", 30);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator pos = find(v.begin(), v.end(), p2);
	if (pos == v.end()) cout << "没有找到" << endl;
	else cout << "找到了，姓名:" << pos->name << " 年龄:" << pos->age << endl;
}

注意：利用find查找容器中的指定元素，返回的是迭代器

2.2 find_if

功能描述：

  • 按条件查找元素

函数原型：

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

示例：

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 pos = find_if(v.begin(), v.end(), GreaterFive());
	if (pos == v.end())
	{
		cout << "没有找到比5大的数字" << endl;
	}
	else
	{
		cout << "找到比5大的数字：" << *pos << endl;
	}
}

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

class Greater20
{
public:
	bool operator()(Person& p)
	{
		return p.age > 20;
	}
};

void test02()
{
	vector<Person> v;
	Person p1("张三", 18);
	Person p2("李四", 20);
	Person p3("王五", 40);
	Person p4("老六", 12);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator pos = find_if(v.begin(), v.end(), Greater20());
	if (pos != v.end())
	{
		cout << "找到比20岁大的人了，name：" << pos->name << "age: " << pos->age << endl;
	}
	else
	{
		cout << "没有找到比20岁大的人了" << endl;
	}
}

2.3 adjacent_find

功能：

  • 查找相邻重复元素

函数原型：

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

示例：

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(3);
	v.push_back(4);
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it != v.end())
	{
		cout << "找到相邻重复的元素了，是：" << *it << endl;
	}
	else
	{
		cout << "没有找到相邻重复的元素" << endl;
	}
}

2.4 binary_search

功能描述：

  • 在有序序列中查找指定元素是否存在

函数原型：

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

示例：

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

注意：二分查找的效率很高，但是要注意要查找的容器必须是有序的

2.5 count

功能描述：

  • 统计元素个数

函数原型：

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

示例：

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(2);
	v.push_back(4);
	v.push_back(2);
	v.push_back(2);
	int num = count(v.begin(), v.end(), 2);
	cout << "2的个数为：" << num << endl;
}

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

void test02()
{
	vector<Person> v;
	Person p1("张三", 18);
	Person p2("李四", 20);
	Person p3("王五", 18);
	Person p4("老六", 12);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	Person p("老八", 18);
	int num = count(v.begin(), v.end(), p);
	cout << "与p年龄相等的人数为：" << num << endl;
}

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

2.6 count_if

功能描述：

  • 按条件统计元素个数

函数原型：

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

示例：

class Greater5
{
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);
	int num = count_if(v.begin(), v.end(), Greater5());
	cout << "大于4的个数为：" << num << endl;
}

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

class AgeLess20
{
public:
	bool operator()(const Person& p)
	{
		return p.age < 20;
	}
};

void test02()
{
	vector<Person> v;
	Person p1("张三", 18);
	Person p2("李四", 20);
	Person p3("王五", 18);
	Person p4("老六", 12);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	int num = count_if(v.begin(), v.end(), AgeLess20());
	cout << "小于20岁的人数：" << num << endl;
}

3. 常用排序算法

算法原型：

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

3.1 sort

功能描述：

  • 对容器内元素进行排序

函数原型：

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

示例：

void print(int val)
{
	cout << val << " ";
}

void test01()
{
	vector<int> v;
	v.push_back(2);
	v.push_back(4);
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	//sort默认排序规则从小到大
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), print);
	cout << endl;
	//从大到小排序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), print);
	cout << endl;
}

3.2 random_shuffle

功能描述：

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

函数原型：

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

示例：

void test01()
{
	srand((unsigned int)time(NULL));
	vector<int> v;
	for (int i = 0; i < 10; ++i) v.push_back(i + 1);
	for_each(v.begin(), v.end(), print);
	cout << endl;
	//打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), print);
	cout << endl;
}

注意：random_shuffle洗牌算法比较使用，使用前记得加随机数种子srand（）

3.3 merge

功能描述：

  • 两个有序容器合并，并存储到另一个容器中

函数原型：

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

示例：

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; ++i)
	{
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	vector<int> target;
	target.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());
	for_each(target.begin(), target.end(), print);
	cout << endl;
}

注意：merge合并的两个容器必须是有序的

3.4 reverse

功能描述：

  • 将容器内的元素进行反转

函数原型：

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

示例：

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	cout << "反转前：" << endl;
	for_each(v.begin(), v.end(), print);
	cout << endl;
	cout << "反转后：" << endl;
	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), print);
	cout << endl;
}
孙同学要努力
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用的遍历算法
萧海的博客
05-03 1699
概述: 算法主要是由头文件 组成。 是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等 体积很小，只包括几个在序列上面进行简单数学运算的模板函数 定义了一些模板类,用以声明函数对象。 常用遍历算法 算法简介： for_each //遍历容器 transform //搬运容器到另一个容器中 for_each 功能描述： 实现遍历容器 函数原型： for_each(iterator beg, iterator end, _func); // 遍历算法 遍历容
遍历算法遍历方案及几个算法实现
06-08
1．遍历方案 　从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作： 　（1）访问结点本身(N)， 　（2）遍历该结点的左子树(L)， 　（3）遍历该结点的右子树(R)。 以上三种操作有六种执行次序： 　NLR、LNR、LRN、NRL、RNL、RLN。
遍历的三种算法——递归、非递归、层次
weixin_46432495的博客
09-26 3195
遍历二叉树 traversing binary tree
搜索算法——遍历
weixin_45452083的博客
06-23 3910
一、深度优先和广度优先 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次 广度优先遍历：从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。 1、深度优先： 　 采用的是堆栈的形式, 即先进后出，深度优先有回溯的操作(没有路走了需要回头)所以相对而言时间会长一点 //深度优先 function byDeepth(data) { let result = []
二叉树的四种遍历算法
热门推荐
指点
03-06 3万+
二叉树在作为一种重要的数据结构，它的很多算法的思想在很多地方都用到了，比如说大名鼎鼎的 STL 算法模板，里面的优先队列（priority_queue）、集合（set、map）等等都用到了二叉树里面的思想，如果有兴趣的小伙伴可以去查找一些这些方面的资料。但是我们现在先不讨论那么高深的数据结构，我们先从二叉树的遍历开始：先来看一下二叉树长什么样子：这是百度来的一张二叉树图，我们可以看到， 这棵二叉树一
5个常用的遍历算法
Bk冗余
07-09 1041
for_each #pragma once #include <iostream> #include <vector> #include <algorithm> #include <functional> using namespace std; void printfs(int val) { cout << val << endl; } void test01() { vector<int> v; v.push_
查找算法，排序算法，遍历算法之Java实现
匿名王同学的博客
08-24 278
文章目录1.查找算法1.二分/折半查找2.排序算法1.冒泡排序（Bubble Sort）-----不推荐2.选择排序（Selection Sort）----不推荐3.插入排序（Insertion Sort）----不推荐4.快速排序（Quick Sort）----推荐5.堆排序（Heap Sort）----推荐 1.查找算法 1.二分/折半查找 时间复杂度：O(logn) 空间复杂度 public static int binarySearch(int[] array, int value) {
【C++】查找算法和排序算法
qionggaobi9328的博客
06-03 432
一、 公共知识 1. 查找技术 （1）顺序查找 查找过程： 从线性表的第一个元素开始，逐个将线性表中的元素与被查元素进行比较，如果相等，则查找成功；若整个线性扫描结束，仍未找到与被查元素相等的元素，则表示线性表中没有被查元素，查找失败。 前提要求： 线性表 查询次数： 最少1次，第一个元素就是要查的元素； 最多n次，最后一个元素才是要查的元素，或者查到最后都没发现要查的元素； 因此平均情况是n/2...
stl算法中文解析.rar
04-05
3. STL算法的实现：例如，快速排序算法在sort函数中的应用，二分查找在lower_bound和upper_bound中的实现。 4. 仿函数和函数对象的使用场景：如自定义比较函数，用于排序或查找操作。 5. STL中的算法和容器的配合...
C++STL实验报告-迭代器和非变异算法
12-30
实验还涉及到第8章的部分例题，虽然具体代码未给出，但通常会涉及更复杂的操作，如使用算法对容器进行排序、查找、合并等。非变异算法如`find_if`、`lower_bound`、`upper_bound`等在这些操作中扮演重要角色，它们...
面试常见基础算法题总结
04-29
7. **排序算法**：快速排序、归并排序和堆排序是常见的排序算法。快速排序在平均情况下效率高，但最坏情况为O(n^2)，可以通过随机化选取枢轴优化。归并排序稳定但需要额外空间，堆排序不稳定但原地排序。 8. **快排...
stl算法Demo
08-06
例如，`Demo4-30`可能展示了排序算法（如`std::sort`），`Demo4-22`可能是关于查找算法（如`std::find`），`Demo4-5`可能涉及到复制操作（如`std::copy`），而`Demo4-31`可能涉及了算法的组合使用，如遍历、过滤和...
P243~245C++常用遍历算法学习笔记.docx
04-13
这些算法都是STL（Standard Template Library）中的一部分，用于实现对容器中的元素进行遍历、查找、排序等操作。 1. for_each算法 for_each算法用于遍历容器中的元素，可以使用普通函数或仿函数（Function Object...
遍历算法（先序，中序，后序，广度，深度）
风铃的博客
07-22 4096
什么是遍历 遍历(Traversal)，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。 1、二叉树基本结构 struct Node { int value; Node* left; Node* right; Node(int value): value(value), left(nullptr), right(nullptr) {} }; 2、先序遍历 （DLR）也叫做先根...
遍历查找，二分查找，两种方法查找有序数组中某元素的下标
naozibuok的博客
12-19 1019
遍历查找，二分查找
C++ 笔记 21 （STL常用算法 - 遍历 & 查找）
pangyushuang的博客
05-02 743
功能：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()。总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略。总结：利用find可以在容器中找到指定的元素，返回值是迭代器。总结：二分查找法效率很高，但是查找的容器中元素必须是有序序列。总结：for_each是最常用的遍历算法，需要熟练掌握。总结：搬运的目标容器必须提前开辟空间，否则无法正常搬运。功能：查找指定元素是否存在。功能：按条件统计元素个数。功能：查找相邻重复元素。功能：按条件查找元素。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 900
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
二叉树遍历算法详解：先序、中序、后序递归实现
"二叉树遍历的三种递归算法定义，包括先序遍历、中序遍历...在实际应用中，STL的容器和算法经常被用来处理各种数据结构问题，如存储、排序和查找。因此，理解和熟练运用这些概念对于任何C++开发者来说都是非常重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值