1. min()/max()
min()函数用于比较得到较小数/字符串。
max()函数用于比较得到较大数/字符串。

int a = 1, b = 2;
string s1 = "wang";
string s2 = "ming";
cout << min(a, b) << endl;
cout << max(a, b) << endl;
cout << min(s1, s2) << endl;
cout << max(s1, s2) << endl;
//输出结果
// 1
// 2
// ming
// wang

2.sort()
基于快速排序算法实现的排序算法，时间复杂度为O(N*logN)。基本格式如下：
sort(数组首指针，数组尾指针，排序规则);
其中，前两个位置都是填指针，第三个位置可以不填，不填默认按由小到大排序。

int arr[4]={1,3,2,4};
sort(arr,arr+4);
//排序结果是 1,2,3,4

也可以自定义排序规则：

//通过自定义规则进行排序
bool map(int x1,int x2){
    return x1>x2;
}
int arr[5]={3,2,1,4,5};
sort(arr,arr+n,map);
//排序结果是 5,4,3,2,1
//规则的位置不仅可重载大小于号，还可以重载其他符号

3.binary_search()
二分查找算法也称折半查找算法Binary Search Algorithm，它是一种效率较高的查找方法，复杂度为O(log**N)。二分查找算法要求线性表（序列）必须采用顺序存储结构，而且表中元素按关键字有序排列。

int arr[4] = {1,2,3,4}; // 升序数组
bool judge1 = binary_search(arr, arr+4, 1); // judge1结果为true
bool judge2 = binary_search(arr, arr+4, 5); // judge2结果为false
//binary_search利用的也是指针

4.lower_bound()
在有序序列里查找不小于关键字的元素，并返回元素索引位置最低的地址，最后根据地址来判断是否查找成功。模板函数lower_bound的基本用途是查找有序区间中第一个大于或等于某给定值的元素的位置。通常最后利用减去数组首地址得到一个数组下标。

int arr[5] = {1,2,4,5,6};
int c = lower_bound(arr,arr+5,4)-arr;
// c的值就是2

5.upper_bound()
模板函数upper_bound的基本用途与lower_bound相对，是查找有序区间中第一个大于某给定值的元素的位置，由此本关卡的任务可以利用upper_bound获取序列中第一个大于待查找关键字的元素的位置。

int arr[5] = {1,2,4,5,6};
int c = upper_bound(arr,arr+5,4)-arr;
// c 的值是 3 

6.equal_range()
模板函数equal_range()综合了lower_bound()和upper_bound()的功能，通过内部调用这两个上下界查找函数，返回两个地址并组成pair：第一个地址是序列中第一个大于等于待查找关键字的元素位置，而第二个地址是第一个大于待查找关键字的元素位置。

int arr[5] = {1,2,2,4,5};
auto bounds = equal_range(arr, arr+5, 2);//auto是自动判断定义类型
int a = bounds.first-arr; // a结果为1
int b = bounds.second-arr; // b结果为3

7.copy()
复制整个数组到新的数组中。

int arr1[4] = {1,3,2,4};
int arr2[4];
copy(arr1, arr1+4, arr2);

8.copy_n()
是可选择的复制前n个元素到新的数组。

int arr1[4] = {1,3,2,4};
int arr2[4];
copy_n(arr1, 4, arr2);

9.swap()
交换两个容器的值。

int a = 1,b = 2;
swap(a,b);
//此时  a = 2, b = 1

10.replace()
replace()为取代模板函数，传入参数first为数组首地址，参数last为数组尾地址，要被替换的旧元素为参数old_value，替换的新的元素为参数new_value，函数功能是将数组中所有的old_value替换为new_value，其函数原型及其应用实例如下：

int arr[4] = {1,2,2,3};
replace(arr, arr+4, 2, 0);
// arr结果为{1,0,0,3}

11.fill()
fill()是Algorithm中的填充模板函数。传入参数first为数组首地址，参数last为数组尾地址，填充值为参数val，函数功能是将数组中的所有元素都重新赋值为val。类似的填充函数还有memset，在头文件string.h中，但是赋值有限，一般仅限于-1，0，若设置为其他数值，则实际结果有误。

int arr[4] = {1,2,3,4};
reverse(arr, arr+4);
// arr结果为{4,3,2,1}

12.rotate()
rotate()是Algorithm中滚动模板函数，传入参数first为数组首地址，参数last为数组尾地址，而参数middle则是数组中要滚动的最后一个元素的后一个地址，滚动完成后该地址将成为首地址，比如数组arr=[0,1,2,3,4]，相应的参数为first=arr，last=arr+5，middle=arr+3，则滚动后的结果为3 4 0 1 2，其函数原型及其应用实例如下：

int arr[5] = {0,1,2,3,4};
rotate(arr, arr+3, arr+5);
\\ arr结果为{3,4,0,1,2}

13.find()
无序数组查找指定元素。与二分查找binary_search()不一样，Algorithm中的模板函数find()可以在无序数组中的查找指定元素x，若存在则返回第一个x所在的地址，否则返回数组尾地址，其函数原型及其应用实例如下，其中传入参数first为数组首地址，参数last为数组尾地址，待查找指定元素为参数val：

int arr[4] = {1,3,2,3};
int *p = find(arr, arr+4, 3); // p结果为地址arr+1
int *q = find(arr, arr+4, 0); // q结果为地址arr+4

14.find_end()
无序数组查找指定数组子序列。Algorithm中的模板函数find_end()可以在无序数组arr1中的查找指定子数组arr2是否存在，若存在则返回待查子数组arr2最后出现在原数组arr1的地址，否则返回原数组的尾地址，例如arr1=[0,3,4,3,4]，arr2=[3,4]，返回结果为arr1+3，其函数原型及其应用实例如下：

int arr[5] = {0,3,4,3,4};
int arr1[2] = {3,4};
int arr2[2] = {3,5};
int *p = find_end(arr, arr+5, arr1, arr1+2); // p结果为地址arr+3
int *q = find_end(arr, arr+5, arr2, arr2+2); // q结果为地址arr+5

15.count()
Algorithm中的模板函数count()可以在数组中统计指定元素x出现的次数，传入参数first为数组首地址，参数last为数组尾地址，参数x为待统计的指定元素，其函数原型及其应用实例如下：

int arr[5] = {0,3,4,3,4};
int cnt = count(arr, arr+5,3); // cnt结果为2

16.equal()
两个数组相等意思是数组个数相同，对应位置上的元素值也相同，Algorithm中的模板函数equal就可以比较两个数组是否相等，返回比较真值。

int arr1[2] = {3,4};
int arr2[2] = {3,4};
int arr3[2] = {3,5};
bool judge1 = equal(arr1, arr1+2, arr2); // judge1结果为地址true
bool judge2 = equal(arr1, arr1+2, arr3); // judge2结果为地址false

17.merge()
合并函数的核心思想是设置两个头指针，分别指向两个升序数组首地址，通过比较两个头指针的大小，每次都将小的数值放入新的数组，然后小数值指针后移，最后新的数组也是有序的，从而完成合并过程，复杂度为O(N+M)。

int arr1[3] = {1,2,3};
int arr2[4] = {2,3,4,5};
int arr3[7];
merge(arr1, arr1+n1, arr2, arr2+n2, arr3);
// arr3结果为{1,2,2,3,3,4,5}

18.includes()
Algorithm中的一个算法，用于检查一个有序序列是否包含另一个有序序列的全部元素（即第二个序列是第一个序列的子序列，不要求连续，但要求元素顺序一致且两个序列均已按相同规则排序）。

int arr1[] = {1, 2, 3, 4};
int arr2[] = {2, 4};
bool result = includes(arr1, arr1+4, arr2, arr2+2); 
// true，因为 2 和 4 都在 arr1 中

19.set_union()
集合的并。集合A和集合B的并是由所有属于集合A或属于集合B的元素所组成的集合，记作A⋃B 或者B⋃A，并集的一个重要属性就是越并越多。假定集合A=(1,2,3,4,5,6,7)，集合B=(6,7,8,9)，那么集合A和集合B的并集为A⋃B=(1,2,3,4,5,6,7,8,9)。
Algorithm算法模板中集成了集合的并操作，函数名称为set_union，其作用是将两个集合合并成一个集合，但是要求输入的两个集合必须是有序的，这看似违背了集合的定义，但是有序的目的是为了让求并的过程实现起来变得简单。

int arr1[3]={1,2,3};
int arr2[3]={2,3,4};
int arr3[4];
int n = set_union(arr1, arr1+n1, arr2, arr2+n2, arr3)-arr3;
// arr3结果为{1,2,3,4}
// n结果为4

20.set_intersection()
集合的交。集合A和B的交是由所有属于集合A以及属于集合B的元素所组成的集合，记作A∩B或者B∩A，交集的一个重要属性就是越交越少。假定集合A=(1,2,3,4,5,6,7)，集合B=(6,7,8,9)，那么集合A和集合B的交集为A∩B=(6,7)。
Algorithm算法模板中集成了集合的交操作，函数名称为set_intersection，其作用是将两个集合交成一个集合，同样的要求输入的两个集合必须是有序的。因此，首先需要将两个集合排序，然后才调用set_intersection()函数计算出交集。其函数原型及应用实例如下，输入参数是两个集合的首尾地址以及一个保存交集结果的数组的首地址，最后返回数组尾地址：

int arr1[3]={1,2,3};
int arr2[3]={2,3,4};
int arr3[2];
int n = set_intersection(arr1, arr1+n1, arr2, arr2+n2, arr3)-arr3;
// arr3结果为{2,3}
// n结果为2

21.set_difference()
集合相对差集。集合差集也叫集合补集，是一个相对的定义：由属于A而不属于B的元素组成的集合，称为B关于A的相对补集，记作A−B。例如集合A=(1,2,3,4)，集合B=(3,4,5,6)，那么集合A−B=(1,2)。
Algorithm算法模板中集成了集合的差操作，函数名称为set_difference()，其作用是计算出两个集合的差集。

int arr1[4]={1,2,3,4};
int arr2[4]={3,4,5,6};
int arr3[4];
int n = set_difference(arr1, arr1+n1, arr2, arr2+n2, arr3)-arr3;
// arr3结果为{1,2}
// n结果为2

22.set_symmetric_difference()
集合对称差集。集合A与集合B的对称差集定义为属于集合A与集合B，但不属于它们交集A∩B的元素集合，记为A△B。也就是说A△B=x∣x∈A∪B且x∈/A∩B，即A△B=(A∪B)—(A∩B)。同样也可以用相对差集的并来表示A△B=(A—B)∪(B—A)。例如上述的两个集合，他们的对称差集为A△B=(1,2,5,6)。
Algorithm算法模板中集成了集合对称差集的操作，函数名称为set_symmetric_difference()，其作用是计算出两个集合的对称差集，同样的，要求输入的两个集合必须是有序的。

int arr1[4]={1,2,3,4};
int arr2[4]={3,4,5,6};
int arr3[8];
int n = set_symmetric_difference(arr1, arr1+n1, arr2, arr2+n2, arr3)-arr3;
// arr3结果为{1,2,5,6}
// n结果为4

23.next_permutation()
一般地，从n个不同元素中取出m个元素，按照一定的顺序排成一列，叫做从n个元素中取出m个元素的一个排列(permutation)。特别地，当m=n时，这个排列被称作全排列(all permutation)。
给定一个排列序列，Algorithm中的模板函数next_permutation()可以产生该排列的下一个序列，输入参数为序列的首地址和尾地址。

do{
       for(int i=0;i<n;i++)cout<<arr[i]<<' ';
       next_permutation(arr,arr+n);
       i++;
   }while(i<m);

24.prev_permutation()
给定一个排列序列，Algorithm中的模板函数prev_permutation可以产生该排列的上一个序列，输入参数为序列的首地址和尾地址。

do{
    for(int i=0;i<n;i++)cout<<arr[i]<<' ';
    prev_permutation(arr,arr+n);
    i++;
}while(i<m);

25.min_element()/max_element()
min_element(start,end)返回地址[start,end）中最小暗度那个值的地址（迭代器），传入参数为两个地址或迭代器。时间复杂度为O(n)。max_element()函数同理。

int arr[] = { 3,5,1,5,6,1,0 };
int n = sizeof(arr) / sizeof(arr[0]);
int min_val = arr[0];
for (int i = 1; i < n; i++)
{
    min_val = min(min_val, arr[i]);
}
cout << "数组最小值为：" << min_val << endl;
 
// 使用 min_element 找到最小元素的迭代器
auto min_it = min_element(arr, arr + n);
// 计算最小元素的下标
int min_index = min_it - arr;
cout << "最小值的下标为：" << min_index << endl;
 
//另一种求法
cout << "最小值：" << *min_element(arr, arr + n) << endl;

26.reverse()
reverse()是一个用于反转容器中元素顺序的函数，它的原型定义在Algorithm头文件中。reverse(first，last)函数接收两个参数：first指向容器中要反转的第一个元素的迭代器。last指向容器中要反转的最后一个元素的下一个位置的迭代器。

int arr[6] = { 1,2,3,6,2,0 };
reverse(arr,arr+6);
vector <int> arr2 = { 3,34,2,6,1 };
reverse(arr2.begin(), arr2.end());

27.unique()
unique()是一个用于去除容器中相邻重复元素的函数，原型定义在Algorithm。unique(first,last)函数接受两个参数：first指向容器中要去重的第一个元素的迭代器，last指向容器中要去重的最后一个元素的下一个位置的迭代器。unique函数将[first,last)范围内的相邻重复元素去除，并返回一个指向去重后范围的尾后迭代器。去重后的范围中只保留了第一个出现的元素，后续重复元素都被移除。可用于去除各种类型的容器中的相邻重复元素，包括数组、向量、链表等。

vector <int> arr = { 1,2,3,3,4,5,5,6,6};
 
unique(arr.begin(), arr.end()); //1 2 3 4 5 6 5 6 6
auto it=unique(arr.begin(), arr.end());//it指向后面的重复元素的第一个元素
arr.erase(it,arr.end());//去除后面重复的部分
 
int a[]={1,1,2,2,3};
int n=unique(a,a+5)-a;  //注意减a的首地址才是下标
 
for (int i = 0; i < 6; i++)
    cout << arr[i] << " ";
cout << endl;

28.islower() / isupper() / isnumber() / isalpha() / isalnum()
islower()和isupper()是C++标准库中的字符分类函数，用于检查一个字符是否为小写或大写字母。isnumber()判断字符是否是数字字符；isalpha()判断是否为数字母；isalnum()判断是否为数字或字母。这些函数返回值都是bool类型。

#include <iostream>
#include <cctype>
using namespace std;
 
int main()
{
    char ch1 = 'A';
    if (islower(ch1))
        cout << "是小写字母" << endl;
    else
        cout << "不是小写字母" << endl;
    if (isupper(ch1))
        cout << "是大写字母" << endl;
    else
        cout << "不是大写字母" << endl;
    return 0;
}

29.tolower() / toupper()
tolower()可以将字符转换为小写字母，如果字符不是小写字母则不进行转换。toupper()可以将字符转换为大写字母。

char ch1 = 'A';
char ch2 = tolower(ch1);
cout << ch2 << endl;