除了少数例外，标准库算法都对一个范围内的元素进行操作。我们将此元素范围称为“输入范围”。接受输入范围的算法总是使用前两个参数来表示此范围，两个参数分别是指向要处理的第一个元素和尾元素之后位置的迭代器。

虽然大多数算法遍历输入范围的方式相似，但它们使用范围中元素的方式不同。理解算法的最基本的方法就是了解它们是否读取元素、改变元素或是重排元素顺序。

只读算法

只可以操作容器元素，不可以改变容器内的值
因为是只读，所以建议使用只读迭代器（cbegin()、cend()）

常见的只读算法：

> find
> count
> accumulate
> equal 

find()

/*定义 find(参数1（起始迭代器），参数2（尾迭代器），参数3（查找的元素）)
功能：遍历一个范围中是否包含某元素
参数：前2个参数是一个迭代器范围或者指针范围。第3个参数是要查找的元素
返回值：成功返回要查找的元素所在的迭代器。失败返回参数2*/

int arr[] = { 1,2,3,4,5 };
int value = 3;
auto result = find(arr + 1, arr + 3, value);
cout << "The value "<<value<<((result == arr + 3)
	?" is not present":"is present")<< endl;

count()

/*count(参数1（起始迭代器），参数2（尾迭代器），参数3（查找的元素）)
参数：前2个参数是一个迭代器范围或者指针范围。第3个参数是要计数的元素
功能：返回元素在指定迭代器范围内出现的次数
返回值：成功返回出现的次数，没有返回0*/

list<int> li{ 1,2,3,66,66,66,100 };
cout <<"The 66 count is：" 
	<<count(li.cbegin(),li.cend(),66)<< endl;

accumulate()

/*accumulate(vec.cbegin(),vec.cend(),0)
头文件：numeric
功能：将指定范围内的元素进行和运算，参数3为和运算的初始值
返回值：返回和运算的结果
注意：此函数操作的元素必须能够与+运算符进行操作，实际上是根据第三个参数的类型决定函数使用哪个加法运算符及返回值类型。*/

//计算li元素的和，和的初始值为0
list<int> li{ 1,2,3 };
cout <<"The sum is：" <<accumulate(li.cbegin(),li.cend(),0)<< endl; //6

//使用string时，必须显示地调用，不能够直接使用字符串，因为这样会被accumulate函数认为是一个const char*对象而出错，因为const char*对象是没有+这种运算的。
ist<string> li{"A","B","C"};
cout <<accumulate(li.cbegin(),li.cend(),string("String："))<< endl; //String：ABC

//如果想要进行别的运行，例如乘、除等，可以使用参数4.例如下面是对一个数组内的元素进行乘操作（备注：初始化不要填0，否则结果就为0）
int *p = new int[4] {1, 2, 3, 4};
cout << accumulate(p, p + 4, 1,multiplies<int>()) << endl; //24

equal()

/*equal(vec1.cbegin(),vec1.cend(), vec2.cbegin())
功能：用来比较两个指定范围内的元素是否都是相同的值（常来比较两个容器是否相同）
参数：参数1和参数2指定一个容器的范围。参数3指定另一个容器的开始范围
比较规则：将参数1和2指定的范围内的所有元素，查看这些元素是否与参数3所指定的另一个容器的开始处是否都存在（不一定要个数都相同，只要容器1的指定开始的元素在容器2中都要一一对应）
返回值：都相同返回1。不相同返回0
因为equal调用迭代器完成操作，所以equal可以用来比较两个不同类型的容器。例如vector<string>和list<const char*>可以进行比较*/

vector<int> vec1{ 2,3};
vector<int> vec2{ 1,2,3,4 };
cout << equal(vec1.cbegin(),vec1.cend(), vec2.cbegin())<< endl; //0

写容器元素算法

将新值赋予给序列中元素，此时要确保序列原大小不小于算法要求写入的元素数目。（算法不会改变容器大小）
迭代器不会检查写入数据位置大小是否足够大

常见的写容器算法：

> fill(beg,end,val) //将val赋给输入序列每个元素
> fill_n(dest,n,val)//从dest开始n个元素赋值为val
> back_inserter
> copy
> copy_backward
> replace
> replace_copy
> next_permutation
> prev_permutation

fill()

/*fill(参数1，参数2，参数3)
用来改变指定位置处的元素
参数：参数1、2指定容器的范围，参数3位要设置的值*/

vector<int> vec{ 1,2,3,4,5,6 };
fill(vec.begin(), vec.begin()+vec.size()/2, 66); //将vec的前半部分元素变为66

for (auto v = vec.cbegin(); v != vec.cend(); v++)
	cout << *v << endl;

fill_n()

fill_n(参数1，参数2，参数3)
用来将指定数量的元素变为某个值
参数：参数1为迭代器起始位置。参数2为要改变的元素个数。参数3为要设定的值
注意：要注意参数2的设定，不能超出容器的大小，也不能对空容器操作

vector<int> vec{ 1,2,3,4,5,6 };

fill_n(vec.begin(), 3, 66); //将vec的前3个元素变为66
for (auto v = vec.cbegin(); v != vec.cend(); v++)
	cout << *v << endl;

fill_n(vec.begin(), vec.size(), 66); //将vec全部变为66
for (auto v = vec.cbegin(); v != vec.cend(); v++)
	cout << *v << endl;

back_inserter()

back_inserter(参数)
又名插入迭代器
参数：为一个容器的引用
返回值：返回与该容器绑定的插入迭代器，或者可以理解为back_inserter函数返回值是指向给定容器尾部的迭代器。
功能：常用来返回一个容器的迭代器，然后对此迭代器进行操作
当我们通过返回的插入迭代器赋值时，会自动调用push_back将一个具有给定值的元素添加到容器中
头文件iterator

vector<int> vec; //空容器

auto it = back_inserter(vec); //返回vec的第一个迭代器
*it = 42; //此时vec有了一个元素，值为42

copy()

copy(参数1，参数2，参数3)
将参数1、2指定范围的元素拷贝给参数3指定的容器
参数：参数1、2为一个容器的范围。参数3要接受拷贝的容器起始位置
注意：参数3要有足够的空间保存拷贝的数据
返回值：返回拷贝目的位置的迭代器值

int arr1[] = { 1,2,3 };
int arr2[sizeof(arr1)/sizeof(*arr1)];

auto ret = copy(begin(arr1), end(arr1), arr2); //将数组1拷贝给数组2。ret为arr2数组最后元素的下一个位置

for (auto i = 0; i < sizeof(arr2) / sizeof(*arr2); i++) {
    cout << arr2[i]<< endl;
}

copy_backward()

/*copy_backward(参数1，参数2，参数3)
该函数与copy的不同之处在于：
copy是从第一个元素开始拷贝，而copy_backward是从最后一个元素开始拷贝
copy的第3个参数是接受拷贝的容器起始位置，而copy_backward是目的序列的结束迭代器
会复制前两个迭代器参数指定的序列。第三个参数是目的序列的结束迭代器
值得注意的是arr1的end和arr2的end元素都是不进行赋值的*/

	int arr1[] = { 1,2,3 };
	int arr2[sizeof(arr1) / sizeof(*arr1)];

	auto ret = copy_backward(begin(arr1), end(arr1), end(arr2)); //将数组1拷贝给数组2。ret为arr2数组最后元素的下一个位置

	for (auto i = 0; i < sizeof(arr2) / sizeof(*arr2); i++) {
		cout << arr2[i] << endl;
	}

replace()

/*replace(参数1，参数2，参数3，参数4)
将指定范围内指定的元素替换为另一个值
参数：1、2指定替换的范围。3：目标值，4：替换后的值
头文件algorithm*/

vector<int> vec{ 1,0,0,0,5 };
replace(vec.begin(), vec.end(), 0,66); //将vec中为0的全部替换为66

for (auto v = vec.cbegin(); v != vec.cend(); v++) {
	cout << *v << endl;
}

replace_copy()

/*replace_copy()
此函数会保留原容器不变，然后将替换后的结果保存在另一个容器中
参数：参数1，2位为要替换的范围。参数3位另一个容器的起始位置。参数4目标值。参数5替换后的值
头文件algorithm*/

vector<int> vec{ 1,0,0,0,5 };
vector<int> vec2;

replace_copy(vec.begin(), vec.end(),back_inserter(vec2), 0,66); //vec的元素保持不变，vec2为替换后的值
	
for (auto v = vec2.cbegin(); v != vec2.cend(); v++) {
    cout << *v << endl;
}

next_permutation()

/*next_permutation(参数1,参数2)
功能：对一个迭代区间的数值进行全排列
返回值：会根据前面next_permutation函数的调用，当操作的区间不存在下一个排列时，函数返回false；否则如果可以继续进行全排列，那么就返回true

函数原型
#include <algorithm>
bool next_permutation(iterator start,iterator end)*/

int *p = new int[3] {1, 2, 3};
do {
    for (int i = 0; i < 3; ++i){
        cout << p[i];
    }
    cout << endl;
} while (next_permutation(p, p + 3));

输出结果：

prev_permutation()

/*prev_permutation()
与next_permutation的功能显示，区别就是prev_permutation是求当前排列的前一个排列，而next_permutation是求当前排列的下一个排列*/

举个例子进行分析：

#include<iostream>
#include<algorithm>
using namespace std;
int a[] = {2, 1, 3};
int main(){
    /*正常的排序：
    1 2 3
    1 3 2
    2 1 3
    2 3 1
    3 1 2
    3 2 1
    */
    if(next_permutation(a, a + 3)){ // 如果下一个字典序全排列存在则输出
        cout << a[0] << ' ' << a[1] << ' ' << a[2] << endl;
    }
    /*
    输出：
    2 1 3
	2 3 1
	3 1 2
	3 2 1
	*/
    if(prev_permutation(a, a + 3)){ // 如果上一个字典序全排列存在则输出
        cout << a[0] << ' ' << a[1] << ' ' << a[2] << endl;
    }
    /*
    输出:
    2 3 1
    1 3 2
    */
}

也就是说如果我们想要全排列，就需要先将此容器进行大小排序，从小到大进行排序之后，再进行next_permutation.

重排容器元素算法

某些算法会重排容器中元素的顺序，一个明显的例子是sort。调用sort 会重排输入序列中的元素，使之有序，它是利用元素类型的<运算符来实现排序的。

常见的重排容器元素的算法：

sort(beg,end); //利用<运算符实现排序
unique(beg,end); //重排，不重复元素排在vector开始部分，返回不重复区域之后一个位置的迭代器
stable_sort(beg,end)

sort()

/*sort(beg,end)
将容器内的元素按照运算符“<”的规则排序，从小到大
参数：一个容器的迭代器范围*/

vector<int> vec{ 1,4,2,8,4,1 };
sort(vec.begin(), vec.end()); //将vec的值从小到大排序

for (auto v = vec.cbegin(); v != vec.cend(); v++) {
    cout << *v << endl;
}

unique()

/*unique()
相邻之间如果有重复相同的元素，则删除重复的元素只保留一个
参数：一个容器的迭代器范围
返回值：返回删除重复元素之后的最后一个元素的后一个位置
注意（重点）：虽然删除了元素，但是容器的大小依然没有变，迭代器也没有变。所有变为迭代器时一定要注意*/

vector<int> vec{ 1,1,2,3,4,4,4,5,1 };
auto end_unique = unique(vec.begin(), vec.end());

//for循环时使用unique的返回值，如果使用vec.cend()，那么会打印后面没有元素位置的乱值
for (auto v = vec.cbegin(); v != end_unique; v++) { 
	cout << *v << endl;
}

stable_sort()

/*stable_sort(beg,end)
与sort()一样也是排序，默认也使用“<”对元素进行排序，而且可保证相等元素的原本相对次序在排序后保持不变*/

vector<int> vec{ 1,10,88,2,100,88,4,1 };
stable_sort(vec.begin(), vec.end());

for (auto v = vec.cbegin(); v != vec.cend(); v++) {
    cout << *v << " ";
}
cout << endl;