c++ primer （第10章 泛型算法） 算法

#include<iostream>
#include<algorithm>
#include<iterator>
#include<vector>
#include<numeric>
#include<string>
#include<list>


using namespace std;
int main()
{
	vector<int> v1 = { 1, 3, 5, 7, 9, };
	vector<string> vs = { "aaa", "bbb", "ccc", "ddd", "eee" };

//只读算法，只读取而不改变元素的算法，通常最好使用cbegin(),cend()
//find算法，接受三个参数，返回值为迭代器，前两个参数为迭代器，第三个参数为要查找的值
//查找成功返回指向第一个等于给定元素的迭代器，查找失败返回第二个参数
	int  key = 11;
	auto iter = find(v1.cbegin(), v1.cend(), key);
	cout << (iter == v1.cend() ? "search failure\n" : "search sucessful\n");

	//find用于内置数组类型
	int a[] = { 4, 2, 3, 4, 5 };
	int *pt = find(begin(a), end(a), 7);        //begin和end函数使用c++11
    //int *pt = find(a, a+5, 7);			          与上一行功能相同，注意第二个参数为查找的下一个位置，即开区间，直至但不包括a[5]
	cout << (pt == end(a) ? "search failure\n" : "search sucessful\n");

//count算法，接受三个参数，返回给定值在序列中出现的次数
	key = 7;
	int ct = count(v1.cbegin(), v1.cend(), key);  
	cout << "ct: " << ct << endl;
	ct = count(begin(a), end(a), 4);             //count同样可用于内置数组类型
	cout << "ct: " << ct << endl;

//accumulate算法，接受三个（可以四个）参数，前两个参数指定求值范围，第三个参数是和的初值，返回求和结果，算法头文件为numeric
	string s1 = "";
	string sum = accumulate(vs.cbegin(), vs.cend(), s1);
	//string sum = accumulate(vs.begin(), vs.end(), "   "); 如此无法通过编译，原因为const char* 类型上没有定义+运算符

	int sum1 = accumulate(v1.cbegin(), v1.cend(), 0);
	cout << "sum: " << sum << endl;
	cout << "sum1: " << sum1 << endl;

//操作两个序列的算法
//equal算法，接受三个迭代器做参数，前两个表示第一个序列的元素范围，第三个参数表示第二个序列的首元素
//根据判断两序列中所有元素是否相等(本质是判断第一个序列是否是第二个序列的子集)返回bool值
//equal算法可以用来比较不同类型容器和不同类型元素的值，如vector<int>={1,2,3},list<double>{1,2,3},equal返回真
//注意，对于只接受一个单一迭代器表示第二个序列的算法，都假定第二个序列长度大于等于第一个序列
	vector<int> v2 = { 1, 3, 5, };
	list<double> v3 = { 1.0, 3.0, 5.0, 7.0, 10.0 };
	bool e = equal(v2.begin(), v2.end(), v3.begin());
	cout << (e == 1 ? "equal" : "not euqal");
	cout << endl;

//写容器元素算法
//fill算法接受一对迭代器表示一个范围，第三个参数为一个值，fill将给定的这个值赋予输入序列中的每个元素
	vector<int> v4 = { 1, 3, 5, 7, 9, 11 };
	fill(v4.begin(), v4.end(), 0);           //元素全部置0
	copy(v4.cbegin(), v4.cend(), ostream_iterator<int>(cout, " "));
	cout << endl;

//fill_n算法接受一个单迭代器、一个计数值、和一个值，它将给定值赋予迭代器指向的元素开始的制定个元素
//注意，fill_n假定写入制定个元素是安全的
	vector<int> v5 = { 1, 3, 5, 7, 9, 11 };
	fill_n(v5.begin(),v5.size()/2,0);       //将v5前半部分置0
	copy(v5.cbegin(), v5.cend(), ostream_iterator<int>(cout, " ")); cout << endl;
	//fill_n(v5.begin(), 10, 0);            //第二个参数超出容器容量，将引发不可预计的后果
	//安全做法，使用插入迭代器back_inserter，以下代码完成在v5尾部插入3个0
	//使用一个普通迭代器向容器元素赋值时，值被赋予迭代器指向的元素。而通过一个插入迭代器赋值时，将把一个新元素添加至容器中
	fill_n(back_inserter(v5), 3, 0);       
	copy(v5.cbegin(), v5.cend(), ostream_iterator<int>(cout, " ")); cout << endl;

//copy算法 ,前两个参数为被拷贝对象的范围，第三个参数表示目的序列的起始位置，函数返回拷贝后目的容器的尾后位置
	int a1[] = { 1, 2, 3, 4, 5 };
	int a2[sizeof(a1) / sizeof(*a1)];  //使a2与a1等长
	copy(begin(a1), end(a1), a2);      //a1拷贝至a2
	copy(begin(a2), end(a2), ostream_iterator<int>(cout, " ")); cout << endl;

	vector<int> v6 = { 1, 3, 5, 7, 9, 11 };
	vector<int> v7 = { 1, 2, 3, 4, 5, 6, };
	copy(v6.begin(), v6.end(), v7.begin());      
	copy(v7.cbegin(), v7.cend(), ostream_iterator<int>(cout, " ")); cout << endl;

//replace算法，读入一个序列并将所有等于给定值的元素都改为另一个值
	vector<int> v8 = { 1, 2, 3, 3, 3, 4 };
	replace(v8.begin(), v8.end(), 3, 7);        //将容器中所有3改为7
	copy(v8.cbegin(), v8.cend(), ostream_iterator<int>(cout, " ")); cout << endl;

//replace_copy算法，相比replace多接受1个参数，不改变原序列的值，将替换体现在新序列上
	vector<int> v9 = { 1, 2, 3, 3, 3, 4 };
	vector<int> v10 = { 10, 20, 30, 30, 30, 40 };
	replace_copy(v8.begin(), v8.end(),v10.begin(), 3, 7);        //将v9中所有3改为7并拷贝至v10,v9本身不变
	copy(v10.cbegin(), v10.cend(), ostream_iterator<int>(cout, " ")); cout << endl;
//unique算法，接受一对迭代器范围，返回一个指向不重复值范围末尾的迭代器
	vector<int> v11 = { 1, 2, 3, 3, 3, 4 };
	auto endv11=unique(v11.begin(), v11.end());
	v11.erase(endv11, v11.end());             //将删除后空出的位置上的元素删除
	copy(v11.cbegin(), v11.cend(), ostream_iterator<int>(cout, " ")); cout << endl;


	system("pause");
	return 1;
}