algorithm算法库学习之——不修改序列的操作

algorithm此头文件是算法库的一部分。本篇介绍不修改序列的操作函数。

不修改序列的操作
all_ofany_ofnone_of (C++11)(C++11)(C++11)	检查谓词是否对范围中所有、任一或无元素为 true (函数模板)
for_each	应用函数到范围中的元素 (函数模板)
for_each_n (C++17)	应用一个函数对象到序列的前 n 个元素 (函数模板)
countcount_if	返回满足指定判别标准的元素数 (函数模板)
mismatch	寻找两个范围出现不同的首个位置 (函数模板)
findfind_iffind_if_not (C++11)	寻找首个满足特定判别标准的元素 (函数模板)
find_end	在特定范围中寻找最后出现的元素序列 (函数模板)
find_first_of	搜索元素集合中的任意元素 (函数模板)
adjacent_find	查找首对相邻的相同（或满足给定谓词的）元素 (函数模板)
search	搜索一个元素范围 (函数模板)
search_n	在范围中搜索一定量的某个元素的连续副本 (函数模板)

示例代码：

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <utility>      // std::pair
#include <vector>
#include <array>
#include <cctype>       // std::tolower


void myfunction(int i) {  // function:
	std::cout << ' ' << i;
}

struct myclass {           // function object type:
	void operator() (int i) { std::cout << ' ' << i; }
} myobject;

bool IsOdd(int i) { return ((i % 2) == 1); }

bool mypredicate(int i, int j) {
	return (i == j);
}

bool myfunction8(int i, int j) {
	return (i == j);
}

bool comp_case_insensitive9(char c1, char c2) {
	return (std::tolower(c1) == std::tolower(c2));
}

bool myfunction10(int i, int j) {
	return (i == j);
}

bool mypredicate11(int i, int j) {
	return (i == j);
}

bool mypredicate12(int i, int j) {
	return (i == j);
}

int main()
{
	// all_of example  检查谓词是否对范围中所有、任一或无元素为 true
	std::array<int, 8> foo = { 3,5,7,11,13,17,19,23 };
	if (std::all_of(foo.begin(), foo.end(), [](int i) {return i % 2; }))
		std::cout << "All the elements are odd numbers.\n";

	// any_of example
	std::array<int, 7> foo2 = { 0,1,-1,3,-3,5,-5 };
	if (std::any_of(foo2.begin(), foo2.end(), [](int i) {return i < 0; }))
		std::cout << "There are negative elements in the range.\n";

	// none_of example
	std::array<int, 8> foo3 = { 1,2,4,8,16,32,64,128 };
	if (std::none_of(foo3.begin(), foo3.end(), [](int i) {return i < 0; }))
		std::cout << "There are no negative elements in the range.\n";

	// for_each example  应用函数到范围中的元素 
	std::vector<int> myvector;
	myvector.push_back(10);
	myvector.push_back(20);
	myvector.push_back(30);

	std::cout << "myvector contains:";
	for_each(myvector.begin(), myvector.end(), myfunction);
	std::cout << '\n';

	// or:
	std::cout << "myvector contains:";
	for_each(myvector.begin(), myvector.end(), myobject);
	std::cout << '\n';

	// count algorithm example 返回满足指定判别标准的元素数 
	// counting elements in array:
	int myints[] = { 10,20,30,30,20,10,10,20,10,20 };   // 8 elements
	int mycount = std::count(myints, myints + 8, 10);
	std::cout << "10 appears " << mycount << " times.\n";

	// counting elements in container:
	std::vector<int> myvector2(myints, myints + 10);
	mycount = std::count(myvector2.begin(), myvector2.end(), 20);
	std::cout << "20 appears " << mycount << " times.\n";

	// count_if example
	std::vector<int> myvector3;
	for (int i = 1; i < 10; i++) myvector3.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9

	int mycount3 = count_if(myvector3.begin(), myvector3.end(), IsOdd);
	std::cout << "myvector3 contains " << mycount3 << " odd values.\n";

	// mismatch algorithm example 寻找两个范围出现不同的首个位置 
	std::vector<int> myvector4;
	for (int i = 1; i < 6; i++) myvector4.push_back(i * 10); // myvector4: 10 20 30 40 50

	int myints4[] = { 10,20,80,320,1024 };                //   myints4: 10 20 80 320 1024

	std::pair<std::vector<int>::iterator, int*> mypair4;

	// using default comparison:
	mypair4 = std::mismatch(myvector4.begin(), myvector4.end(), myints4);
	std::cout << "First mismatching elements: " << *mypair4.first;
	std::cout << " and " << *mypair4.second << '\n';

	++mypair4.first; ++mypair4.second;

	// using predicate comparison:
	mypair4 = std::mismatch(mypair4.first, myvector4.end(), mypair4.second, mypredicate);
	std::cout << "Second mismatching elements: " << *mypair4.first;
	std::cout << " and " << *mypair4.second << '\n';

	// find example
	// using std::find with array and pointer:
	int myints5[] = { 10, 20, 30, 40 };
	int *p;

	p = std::find(myints5, myints5 + 4, 30);
	if (p != myints5 + 4)
		std::cout << "Element found in myints5: " << *p << '\n';
	else
		std::cout << "Element not found in myints5\n";

	// using std::find with vector and iterator:
	std::vector<int> myvector5(myints5, myints5 + 4);
	std::vector<int>::iterator it;

	it = find(myvector5.begin(), myvector5.end(), 30);
	if (it != myvector5.end())
		std::cout << "Element found in myvector5: " << *it << '\n';
	else
		std::cout << "Element not found in myvector5\n";

	// find_if example
	std::vector<int> myvector6;
	myvector6.push_back(10);
	myvector6.push_back(25);
	myvector6.push_back(40);
	myvector6.push_back(55);
	std::vector<int>::iterator it6 = std::find_if(myvector6.begin(), myvector6.end(), IsOdd);
	std::cout << "The first odd value is " << *it6 << '\n';

	// find_if_not example
	std::array<int, 5> foo7 = { 1,2,3,4,5 };
	std::array<int, 5>::iterator it7 = std::find_if_not(foo7.begin(), foo7.end(), [](int i) {return i % 2; });
	std::cout << "The first even value is " << *it7 << '\n';

	// find_end example
	int myints8[] = { 1,2,3,4,5,1,2,3,4,5 };
	std::vector<int> haystack8(myints8, myints8 + 10);
	int needle1[] = { 1,2,3 };
	// using default comparison:
	std::vector<int>::iterator it8;
	it8 = std::find_end(haystack8.begin(), haystack8.end(), needle1, needle1 + 3);
	if (it8 != haystack8.end())
		std::cout << "needle1 last found at position " << (it8 - haystack8.begin()) << '\n';
	int needle2[] = { 4,5,1 };
	// using predicate comparison:
	it8 = std::find_end(haystack8.begin(), haystack8.end(), needle2, needle2 + 3, myfunction8);
	if (it8 != haystack8.end())
		std::cout << "needle2 last found at position " << (it8 - haystack8.begin()) << '\n';

	// find_first_of example
	int mychars9[] = { 'a','b','c','A','B','C' };
	std::vector<char> haystack9(mychars9, mychars9 + 6);
	std::vector<char>::iterator it9;
	int needle9[] = { 'A','B','C' };
	// using default comparison:
	it9 = find_first_of(haystack9.begin(), haystack9.end(), needle9, needle9 + 3);
	if (it9 != haystack9.end())
		std::cout << "The first match is: " << *it9 << '\n';
	// using predicate comparison:
	it9 = find_first_of(haystack9.begin(), haystack9.end(),
		needle9, needle9 + 3, comp_case_insensitive9);
	if (it9 != haystack9.end())
		std::cout << "The first match is: " << *it9 << '\n';

	// adjacent_find example
	int myints10[] = { 5,20,5,30,30,20,10,10,20 };
	std::vector<int> myvector10(myints10, myints10 + 8);
	std::vector<int>::iterator it10;
	// using default comparison:
	it10 = std::adjacent_find(myvector10.begin(), myvector10.end());
	if (it10 != myvector10.end())
		std::cout << "the first pair of repeated elements are: " << *it10 << '\n';
	//using predicate comparison:
	it10 = std::adjacent_find(++it10, myvector10.end(), myfunction10);
	if (it10 != myvector10.end())
		std::cout << "the second pair of repeated elements are: " << *it10 << '\n';

	// search algorithm example
	std::vector<int> haystack11;
	// set some values:        haystack11: 10 20 30 40 50 60 70 80 90
	for (int i = 1; i < 10; i++) 
		haystack11.push_back(i * 10);
	// using default comparison:
	int needle11[] = { 40,50,60,70 };
	std::vector<int>::iterator it11;
	it11 = std::search(haystack11.begin(), haystack11.end(), needle11, needle11 + 4);
	if (it11 != haystack11.end())
		std::cout << "needle11 found at position " << (it11 - haystack11.begin()) << '\n';
	else
		std::cout << "needle11 not found\n";

	// using predicate comparison:
	int needle21[] = { 20,30,50 };
	it11 = std::search(haystack11.begin(), haystack11.end(), needle21, needle21 + 3, mypredicate11);

	if (it11 != haystack11.end())
		std::cout << "needle21 found at position " << (it11 - haystack11.begin()) << '\n';
	else
		std::cout << "needle21 not found\n";

	// search_n example
	int myints12[] = { 10,20,30,30,20,10,10,20 };
	std::vector<int> myvector12(myints12, myints12 + 8);
	std::vector<int>::iterator it12;
	// using default comparison:
	it12 = std::search_n(myvector12.begin(), myvector12.end(), 2, 30);
	if (it12 != myvector12.end())
		std::cout << "two 30s found at position " << (it12 - myvector12.begin()) << '\n';
	else
		std::cout << "match not found\n";
	// using predicate comparison:
	it12 = std::search_n(myvector12.begin(), myvector12.end(), 2, 10, mypredicate12);
	if (it12 != myvector12.end())
		std::cout << "two 10s found at position " << int(it12 - myvector12.begin()) << '\n';
	else
		std::cout << "match not found\n";


	std::cout << "hello world\n";

	return 0;
}

运行结果：