C++常用库函数

大小写转换

islower/isupper函数

用于检查一个字符是否为小写或大小字母，需要包含头文件< cctype >,也可以包含万能头文件< bits/stdc++.h >.函数返回值类型为bool类型。

int main()
{
	char ch1 = 'A';
	char ch2 = 'b';
	//使用islower函数判断是否为小写字母
	if (islower(ch1))
	{
		cout << ch1 << "是小写" << endl;
	}
	else
	{
		cout << ch1 << "是大写" << endl;
	}

	if (isupper(ch2))
	{
		cout << ch2 << "是大写" << endl;
	}
	else
	{
		cout << ch2 << "是小写" << endl;
	}
	return 0;
}

tolower/toupper函数

tolower()可以将ch转化为小写字母，如果不是大写字母则不进行操作，toupper()同理。

int main()
{
	char ch1 = 'A';
	char ch2 = 'b';
	char lowerCh1 = tolower(ch1);
	cout << ch1 << "的小写" << lowerCh1 << endl;
	char upperCh2 = toupper(ch2);
	cout << ch2 << "的大写" << upperCh2 << endl;
	return 0;
}

ASCII码

我们绕过’c’-‘a’+‘A’=‘C’；
在ASCLL码表中，大写字母的编码范围是65(‘A’)到90(‘Z’)，而小写字母的编码范围是97(‘a’)到122(‘z’)根据这个规则，可以使用ASCLL码表进行大小写转换。
数字6也可以以通过字符转化而来’6’-‘0’=6.

排序

sort函数

在使用前需要加头文件#incldue< algorithm >，或用万能头文件。sort是C++标准库中的函数模板，用于指定范围的元素内的排序
sort算法使用的是快速排序，平局时间复杂度一般为O(nlogn)。

sort函数用法

sort(起始地址，结束地址的下一位，*比较函数)
注意（*表示可有可不有。）

#include<algorithm>
int main()
{
	int a[1000];
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}

	sort(a + 1, a + n + 1);//从a[1]到a[n+1] [1,n+1)左闭右开
	for (int i = 1; i <= n; i++)
	{
		cout << a[i] << ' ';
	}
}

运行结果：

#include<vector>
int main()
{
	vector<int>v = { 5,2,8,9,7 };
	//容器用迭代器
	sort(v.begin(), v.end());
	for (auto& i : v)
	{
		cout << i << ' ';
	}
	return 0;
}

运行结果：

自定义比较函数

sort默认使用小于号，要是想自定义比较规则,可以传入第三个参数，可以是函数或lambda表达式(匿名函数)

#include<vector>
//比较函数
bool cmp(const int& u, const int& v)
{
	return u > v;
}

int main()
{
	vector<int>v = { 5,2,8,9,7 };
	//容器用迭代器
	sort(v.begin(), v.end(),cmp);
	for (auto& i : v)
	{
		cout << i << ' ';
	}
	return 0;
}

运行结果：

int main()
{
	vector<int>v = { 3,2,6,1,5 };
	//用lambda表达式
	sort(v.begin(), v.end(), [](const int& u, const int& v)
		{
			return u > v;
		});
	for (auto& i : v)
	{
		cout << i << ' ';
	}
}

结构体比较

结构体可以使用小括号重载后进行排序，当然用前面的方法也是可行的

struct Node
{
	int u, v;
	bool operator<(const Node& m)const
	{
		//以u为第一关键字，v为第二关键字
		return u == m.u ? v < m.v : u < m.u;
	}
};

memset()

memset()是一个用于设置内存块值的函数
memset()函数接受三个参数：
1.ptr：指向要设置值的内存块的指针。
2.value：要设置的值，通常是一个整数。
3.num：要设置的字节数。
memset()函数将ptr指向的内存块的前num个字节设置为value的值。它返回一个指向ptr的指针。memset()函数通常用于初始化内存块，将其设置为特定的值。
例如，如果要将一个整型数组的所有元素设置为0，可以使用memset()函数如下：int arr[10];memset(arr, 0, sizeof(arr))；
在上述示例中，memset(arr,0,sizeof(arr))将数组arr的所有元素设置为0。
需要注意的是，memset()函数对于非字符类型的数组可能会产生未定义行为。在处理非字符类型的数组时，更好使用C++中的其他方法，如循环遍历来初 组memset会将每个byte设置为value。

#include<cstring>
int main()
{
	int a[5];
	memset(a, 0, sizeof(a));
	for (auto i : a)
	{
		cout << i << ' ';
	}

}

当我们初始化1时结果和我们预想的不一样

因为它把四个byte都设成1，因为int是32bit,所以我们会得到00000001 00000001 00000001 00000001
我们一般都将其设置为0,-1(补码是全部都是1)，0x3f(0x表示16进制，一个很大的整数)

swap()

swap(T&a，T&b)函数接受两个参数：
1.a：要交换值的第一个变量的引用。
2.b：要交换值的第二个变量的引用。
swap()函数通过将第一个变量的值存储到临时变量中，然后将第二个变量的值赋给第一个变量，最后将临时变量的值赋给第二个变量，实现两个变量值的交换。
swap()函数可以用于交换任意类型的变量，包括基本类型(如整数、浮点数等)和自定义类型(如结构体、类对象等)。
以下是一个示例，展示如何使用swap(0函数交换两个整数的值：

reverse()

用于反转容器元素顺序的函数。
reverse()函数接受两个参数：
1.first：指向容器中要反转的第一个元素的迭代器。
2.last：指向容器中要反转的最后一个元素的下一个位置的迭代器。reverse()函数将[first, last)范围内的元素顺序进行反转。
也就是说，它会将[first.last)范围内的元素按相反的顺序重新排列。reverse()函数可用于反转各种类型的容器，包括数组、向量、链表等。以下是一个示例，展示如何使用reverse()函数反转一个整型向量的元素顺序：

reverse(vec.begin()，vec.end())将整型向量vec中的元素顺序进行反转。最终输出的结果是54321。
需要注意的是，reverse()函数只能用于。对于只支持双向迭代器的容器，因为它需要能够向前和向后遍历容器，对与单向迭代器的容器（如前向链表），无法使用revere函数进行反转。

unique()

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

unique返回的是5后面那个4的迭代器或者地址
注意：
在上述示例中，unique(v.begin()，v.end())将整型向量vec中的相邻重复元素去除。最终输出的结果是12345。
需要注意的是，unique()函数只能去除相邻的重复元素，如果容器中存在非相邻的重复元素，则无法去除。
如果需要去除所有重复元素，而不仅仅是相邻的重复元素，可先对容器进行排序，然后再使用unique()函数。
unique()时间复杂度为O(n)。

排列

next_permutation()函数

next_permutation 函数用于生成当前序列的下一个排列。它按照字典序对序列进行重新排列，如果存在下一个排列，则将当前序列更改为下一个排列，并返回true；如果当前序列已经是最后一个排列，则将序列更改为第一个排列，并返回false。

prev_permutation()函数

prev_permutation 函数与 next_permutation 函数相反，它用于生成当前序列的上一个排列。它按照字典序对序列进行重新排列，如果存在上一个排列，则将当前序列更改为上一个排列，并返回true；如果当前序列已经是第一个排列，则将序列更改为最后一个排列，并返回 false。

我们一般是用搜索来求一个数组的全排列。
假如我们从中间开始排列

最值查找

min和max函数

min(a, b)返回a和b中较小的那个值，只能传入两个值，或传入一个列表。例如：
min(3，5)=3
min({1, 2, 3, 4})=1
max(a, b)返回a和b中较大的那个值，只能传入两个值，或传入一个列表。例如：
max(7, 5) = 7
min([1, 2, 3, 4}) = 4
时间复杂度为O(1)，传入参数为数组时时间复杂度为O(n)，n为数组大小。min, max函数是在取最值操作时最常用的操作。

min_element和max_element

min_element(st, ed)返回地址[st, ed)中最小的那个值的地址(迭代器)，传入参数为两个地址或迭代器。
max_element(st, ed)返回地址[st, ed)中最大的那个值的地址(迭代器)，传入参数为两个地址或迭代器。
时间复杂度均为O(n)，n为数组大小(由传入的参数决定)。

nth_element函数

nth_element(st, k, ed)
进行部分排序，返回值为void()
传入参数为三个地址或迭代器。其中第二个参数位置的元素将处于正确位置，其他位置元素的顺序可能是任意的，但前面的都比它小，后面的都比它大。
时间复杂度O(n)。

二分查找

binary_search

binary_search是C++标准库中的一个算法函数，用于在已排序的序列(例如数组或容器)中查找特定元素。
它通过二分查找算法来确定序列中是否存在目标元素。
函数返回一个bool值，表示目标元素是否存在于序列中。
如果需要获取找到的元素的位置，可以使用
std::lower_bound函数或
std::upper_bound函数。

lower_bound和upper_bound

前提：数组必须为非降序。
如果要在非升序的数组中使用，可以通过修改比较函数实现(方法与sort自定义比较函数类似)。
lower_bound(st, ed,x)返回地址[st,ed)中第一个大于等于x的元素的地址。
upper_bound(st, ed, x)返回地址[st, ed)中第一个大于x的元素的地址。
如果不存在则返回最后一个元素的下一个位置，在vector中即end()。