C++ STL算法adjacent_find（09）

最新推荐文章于 2024-02-17 18:08:08 发布
最新推荐文章于 2024-02-17 18:08:08 发布
阅读量203 收藏
点赞数
分类专栏： # c++ STL algorithm算法库 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30460949/article/details/121783311
版权

函数原型

//版本
//查找 2 个连续相等的元素
template<class _FwdIt>
_NODISCARD inline _FwdIt adjacent_find(const _FwdIt _First, const _FwdIt _Last)


//带谓词版本
//查找 2 个连续满足 pred 规则的元素
template<class _FwdIt, class _Pr>
_NODISCARD inline _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, _Pr _Pred)

函数用于在区间[开始, 结束)范围内查找 2 个连续相等的元素。返回的迭代器指向前两个相等元素中的第一个。如果没有一对相等的元素，这个算法返回这个序列的结束迭代器。

参数

_First,_Last
输入迭代器输入到序列的初始和最终位置。使用的范围是[_First,_Last]，它包含_First和_Last之间的所有元素，包括first指向的元素，但不包括_Last指向的元素。

_Pred

函数或者谓词（返回bool类型的仿函数），返回的值指示此函数的上下文中是否为元素的匹配项

 版本

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>


int main()
{
	std::vector<int> aa{ 1, 2, 4, 3, 23, 3, 10, 22, 3 };

	auto it = std::adjacent_find(std::begin(aa), std::end(aa));

	if (it == std::end(aa)) 
	{
		std::cout << "No matching adjacent elements\n";
	}
	else 
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(aa), it) << ", *it = "
			<< *it << '\n';
	}

	std::string ss{ "she is the best good!!" };
	auto it1 = std::adjacent_find(std::begin(ss), std::end(ss));
	if (it1 == std::end(ss))
	{
		std::cout << "No matching adjacent elements\n";
	}
	else
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(ss), it1) << ", *it1 = "
			<< *it1 << '\n';
	}

	return -1;
}

//输出
No matching adjacent elements
The first adjacent pair of equal elements is at 17, *it1 = o

 带谓词版本

 函数

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>


bool Pred(int a, int b)
{
	std::cout << "a = " << a << "; b = " << b << std::endl;
	return a == b * 2;
}

int main()
{
	std::vector<int> aa{ 1, 4, 2, 3, 23, 3, 10, 5, 3 };

	auto it = std::adjacent_find(std::begin(aa), std::end(aa), Pred);

	if (it == std::end(aa)) 
	{
		std::cout << "No matching adjacent elements\n";
	}
	else 
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(aa), it) << ", *it = "
			<< *it << '\n';
	}
	std::cout << std::endl;

	std::string ss{ "she is the best good!!" };
	auto it1 = std::adjacent_find(std::begin(ss), std::end(ss), Pred);
	if (it1 == std::end(ss))
	{
		std::cout << "No matching adjacent elements\n";
	}
	else
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(ss), it1) << ", *it1 = "
			<< *it1 << '\n';
	}

	return -1;
}


//输出
a = 1; b = 4
a = 4; b = 2
The first adjacent pair of equal elements is at 1, *it = 4

a = 115; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 105
a = 105; b = 115
a = 115; b = 32
a = 32; b = 116
a = 116; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 98
a = 98; b = 101
a = 101; b = 115
a = 115; b = 116
a = 116; b = 32
a = 32; b = 103
a = 103; b = 111
a = 111; b = 111
a = 111; b = 100
a = 100; b = 33
a = 33; b = 33
No matching adjacent elements

仿函数


#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>


bool Pred(int a, int b)
{
	std::cout << "a = " << a << "; b = " << b << std::endl;
	return a == b * 2;
}

class Pre
{
public:
	bool operator()(int a, int b)
	{
		std::cout << "a = " << a << "; b = " << b << std::endl;
		return a == b * 2;
	}
};

int main()
{
	std::vector<int> aa{ 1, 4, 2, 3, 23, 3, 10, 5, 3 };
	auto it = std::adjacent_find(std::begin(aa), std::end(aa), Pre());

	if (it == std::end(aa)) 
	{
		std::cout << "No matching adjacent elements\n";
	}
	else 
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(aa), it) << ", *it = "
			<< *it << '\n';
	}
	std::cout << std::endl;

	std::string ss{ "she is the best good!!" };
	auto it1 = std::adjacent_find(std::begin(ss), std::end(ss), Pre());
	if (it1 == std::end(ss))
	{
		std::cout << "No matching adjacent elements\n";
	}
	else
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(ss), it1) << ", *it1 = "
			<< *it1 << '\n';
	}

	return -1;
}

//输出
a = 1; b = 4
a = 4; b = 2
The first adjacent pair of equal elements is at 1, *it = 4

a = 115; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 105
a = 105; b = 115
a = 115; b = 32
a = 32; b = 116
a = 116; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 98
a = 98; b = 101
a = 101; b = 115
a = 115; b = 116
a = 116; b = 32
a = 32; b = 103
a = 103; b = 111
a = 111; b = 111
a = 111; b = 100
a = 100; b = 33
a = 33; b = 33
No matching adjacent elements

 bind

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>


bool Pred(int a, int b)
{
	std::cout << "a = " << a << "; b = " << b << std::endl;
	return a == b * 2;
}

class Pre
{
public:
	bool operator()(int a, int b)
	{
		std::cout << "a = " << a << "; b = " << b << std::endl;
		return a == b * 2;
	}
};

int main()
{
	std::vector<int> aa{ 1, 4, 2, 3, 23, 3, 10, 5, 3 };

	auto f1 = std::bind(Pred, std::placeholders::_1, std::placeholders::_2);
	auto it = std::adjacent_find(std::begin(aa), std::end(aa), f1);

	if (it == std::end(aa)) 
	{
		std::cout << "No matching adjacent elements\n";
	}
	else 
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(aa), it) << ", *it = "
			<< *it << '\n';
	}
	std::cout << std::endl;

	std::string ss{ "she is the best good!!" };
	auto f2 = std::bind(Pre(), std::placeholders::_1, std::placeholders::_2);
	auto it1 = std::adjacent_find(std::begin(ss), std::end(ss), f2);
	if (it1 == std::end(ss))
	{
		std::cout << "No matching adjacent elements\n";
	}
	else
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(ss), it1) << ", *it1 = "
			<< *it1 << '\n';
	}

	return -1;
}

//输出
a = 1; b = 4
a = 4; b = 2
The first adjacent pair of equal elements is at 1, *it = 4

a = 115; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 105
a = 105; b = 115
a = 115; b = 32
a = 32; b = 116
a = 116; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 98
a = 98; b = 101
a = 101; b = 115
a = 115; b = 116
a = 116; b = 32
a = 32; b = 103
a = 103; b = 111
a = 111; b = 111
a = 111; b = 100
a = 100; b = 33
a = 33; b = 33
No matching adjacent elements

 lambda

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>

int main()
{
	std::vector<int> aa{ 1, 4, 2, 3, 23, 3, 10, 5, 3 };
	auto it = std::adjacent_find(std::begin(aa), std::end(aa), [](int a, int b) { 
		std::cout << "a = " << a << "; b = " << b << std::endl;
		return a == b * 2; });

	if (it == std::end(aa)) 
	{
		std::cout << "No matching adjacent elements\n";
	}
	else 
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(aa), it) << ", *it = "
			<< *it << '\n';
	}
	std::cout << std::endl;

	std::string ss{ "she is the best good!!" };
	auto it1 = std::adjacent_find(std::begin(ss), std::end(ss), [](int a, int b) {
		std::cout << "a = " << a << "; b = " << b << std::endl;
		return a == b * 2; });
	if (it1 == std::end(ss))
	{
		std::cout << "No matching adjacent elements\n";
	}
	else
	{
		std::cout << "The first adjacent pair of equal elements is at "
			<< std::distance(std::begin(ss), it1) << ", *it1 = "
			<< *it1 << '\n';
	}

	return -1;
}

//输出
a = 1; b = 4
a = 4; b = 2
The first adjacent pair of equal elements is at 1, *it = 4

a = 115; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 105
a = 105; b = 115
a = 115; b = 32
a = 32; b = 116
a = 116; b = 104
a = 104; b = 101
a = 101; b = 32
a = 32; b = 98
a = 98; b = 101
a = 101; b = 115
a = 115; b = 116
a = 116; b = 32
a = 32; b = 103
a = 103; b = 111
a = 111; b = 111
a = 111; b = 100
a = 100; b = 33
a = 33; b = 33
No matching adjacent elements

小魔王降临
关注
专栏目录
STL algorithm算法（01）：adjacent_find
King_DJF的博客
02-13 532
这段时间非常苦恼，看完基本的C++语法知识入门后，没有找到进一步提高的路径，数据结构与算法看的十分吃力，进度缓慢，算是进入瓶颈期了，而且手头上没有可以实践提高的项目。思索下来，STL模板库作为C++的一个重要工具，我只对其容器类有较多的了解，对于算法部分比较陌生，加上这段实践有闲，所以就看看C++官网的介绍，翻译下来，也是学习提高的一种方式。 adjacent意为邻近的。adjacent_fin
C++ STL非更易型算法 查找两个连续且相等的元素adjacent_find
qq_44800780的博客
12-24 227
返回[_First,_Last)区间内第一对连续两个相等元素中的第一元素位置 返回[_First,_Last)区间内第一对连续两个元素均造成_Pred(elem,nextElem)结果为true的第一元素位置. 如果没有找到匹配元素，返回end 复杂度：线性，最多比较numElems次 使用例子： template<typename T> inline void PRINT_ELEM...
c++ STL算法count_if（05）
苦逼的程序猿
12-07 584
函数原型 template<class _InIt, class _Pr> _NODISCARD inline _Iter_diff_t<_InIt> count_if(_InIt _First, _InIt _Last, _Pr _Pred) count_if可以统计容器中满足特定条件的元素的个数。 参数 _First,_Last 输入迭代器输入到序列的初始和最终位置。使用的范围是[_First,_Last]，它包含_First和_Last之间的所...
简单的程序诠释C++ STL算法系列之七：count_if
huobengluantiao8
10-09 258
C++STL的非变易算法（Non-mutating algorithms）是一组不破坏操作数据的模板函数，用来对序列数据进行逐个处理、元素查找、子序列搜索、统计和匹配。 count_if算法是使用谓词判断pred统计迭代器区间[first , last) 上满足条件的元素个数n，按计数n是否引用返回，有如下两种函数原型： 函数原型： template&lt;class InputItera...
C++标准模板（STL）- 算法 （std::count, std::count_if）
qq_40788199的博客
10-14 1565
返回范围 [first, last) 中满足特定判别标准的元素数。 1) 计数等于 value 的元素。 3) 计数谓词 p 对其返回 true 的元素。 2,4) 同 (1,3) ，但按照 policy 执行。这些重载仅若 std::is_execution_policy_v 为 true 才参与重载决议。
std count_if用法
记事本
09-22 2530
#include #include nTotalCount= count_if(containerls.vPointers.begin(),containerls.vPointers.end(),bind2nd(compareuserinfoT(),deptmitm.ulDepartID)); nOnlineCount= count_if(containerls.vPointers.b
C++ STL常用算法 学习总结
最新发布
weixin_45231931的博客
02-17 547
end1 容器1结束迭代器 beg2 容器2开始迭代器 end2 容器2结束迭代器 dest 目标容器开始迭代器。beg1 容器1开始迭代器，end1 容器1结束迭代器，beg2 容器2开始迭代器，end2 容器2结束迭代器。beg 开始迭代器，end 结束迭代器，oldvalue 旧元素，newvalue 新元素。beg 开始迭代器，end 结束迭代器，_Pred 谓词，newvalue 替换的新元素。查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
C++STL算法全集：从for_each到find_first_of
"C++STL算法集合，包含80余个常用算法，还有30余种在持续收集，可作为算法参考字典。" C++ STL（Standard Template Library，标准模板库）是C++编程中非常重要的一个部分，它提供了一系列高效且泛化的容器、迭代器...
C++常用算法（二）：查找【find：查找元素；find_if：条件查找；adjacent_find：查找相邻重复元素；binary_search：二分查找；count：统计元素频次】
u013250861的博客
06-12 341
算法主要是由头文件 组成。是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等…体积很小，只包括在几个序列容器上进行的简单运算的模板函数. 定义了一些模板类,用以声明函数对象。...
STL adjacent_find（）
qq_21441793的博客
02-08 240
本文内容来自C++Plus，本文只是本人的总结和翻译而已。本人只是C++的搬运工。原文传送门：http://www.cplusplus.com/reference/algorithm/adjacent_find/adjacent_find（）算法：查找相邻且相等的元素。作用：查找一个区间[First,Last)之间是否有相邻且相等的元素。若果有就返回这两个元素中的第一个元素的迭代器对象并且返回，如...
STL: adjacent_find
weixin_30469895的博客
03-07 59
adjacent_find Searches for two adjacent elements that are either equal or satisfy a specified condition.即，找出第一组满足条件的相邻元素。 template<class ForwardIterator> ForwardIterator adjacent_find( ...
C++ STL标准库：算法＜algorithm＞ count() count_if() 计数函数用法
超级大洋葱的博客
12-17 6027
#include <functional> #include <iostream> #include <vector> #include <algorithm> using namespace std; template <class T> void FillValue(T& vect, int first, int last) { if (last >= first) { for (int i = first; i &l
STL-adjacent_find算法
一亩三分地儿
09-23 466
adjacent_find算法用于在容器中查找相邻重复元素。 adjacent_find算法实现源码如下： template inline _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last) { return (_STD adjacent_find(_First, _Last, equal_to<>())); } templa
std::count、std::count_if 用法
滴水穿石的博客
01-18 1942
描述：        得到容器中满足条件的元素数量。 定义： template< class InputIt, class T > typename iterator_traits<InputIt>::difference_type count( InputIt first, InputIt last, const T &value ); template< class InputIt, class T > con
STL none_of算法
qq_21441793的博客
02-08 364
本文内容来自C++Plus，本文只是本人的总结和翻译而已。本人只是C++的搬运工。原文传送门：http://www.cplusplus.com/reference/algorithm/none_of/none_of 算法:没有元素符合测试条件。如果[first,last)区间里面有元素满足 perd 条件，就返回false，或者区间是empty也会返回false。如果没有元素满足条件就返回ture...
STL_算法_查找算法(adjacent_find)
寻找&星空の孩子
01-12 2711
C++ Primer 学习中。。。   简单记录下我的学习过程 (代码为主) adjacent_find         //用来查找连续两个相等的或者符合方法的 #include #include #include #include #include using namespace std; /*******************
C++_STL_all_of
weixin_30603633的博客
01-26 97
all_of 功能描述 如果在[first,last)范围内的数组进行判断， 如果pred返回true返回true 否则返回false 等同于 template<class InputIterator, class UnaryPredicate> bool all_of (InputIterator first, InputIterator last, UnaryPredicat...
C++ （all_of；any_of；none_of）
baidu_34884208的博客
02-22 3718
一、all_of 头文件algorithm template &amp;amp;lt;class InputIterator, class UnaryPredicate&amp;amp;gt; bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred); 测试范围内所有元素的条件 如果pred对范围[first，last]中的所有元素...
Boost算法库——C++11算法（none_of）
一世豁然的专栏
10-31 648
头文件'boost / algorithm / cxx11 / none_of.hpp'包含单个算法的四个变体，none_of。 该算法测试序列的所有元素，如果它们没有共享属性，则返回true。 例程none_of采用序列和谓词。 如果谓词在应用于序列中的每个元素时返回false，它将返回true。 例程none_of_equal需要一个序列和一个值。 如果序列中的所有元素
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值