---

前言

最近开始准备蓝桥杯C++组的比赛了,是在自己学习过程中的记录,也分享给大家! 一些蓝桥杯C++竞赛常用库函数!

---

一、二分查找

1. 二分查找的前提

1.数只能对数组进行二分查找
2.这个数组中的元素只能是单调的
3.一般是单调递减,单调递增也行(需修改比较函数）

2.binary_search函数

std::binary_search 函数定义在 头文件中，用于在已排序的序列（数组或容器）中查找特定的元素，通过二分查找来确定序列中是否存在目标元素，返回bool值
二分查找的时间复杂度为 O(log n)，其中 n 是序列的大小。这是因为在每一次比较中，二分查找将搜索范围减半，直到找到目标值或者搜索范围为空为止。

//使用例程
#include <iostream>
#include <vector>
#include <algorithm> // 包含 <algorithm> 头文件int main() {std::vector<int> vec = {1, 3, 5, 7, 9};// 在有序序列中查找目标值 5if (std::binary_search(vec.begin(), vec.end(), 5)) {std::cout << "目标值 5 存在于序列中" << std::endl;} else {std::cout << "目标值 5 不存在于序列中" << std::endl;}return 0;
}

3.lower_bound函数和upper_bound函数

lower_bound（st,ed,x）返回地址[st,ed）中第一个大于等于x的元素的地址(迭代器)。
upper_bound（st,ed,x）返回地址[st,ed）中第一个大于x的元素的地址(迭代器)。

//例子
#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec = {1, 2, 2, 3, 3, 3, 5};// 使用 lower_bound 查找第一个大于等于 3 的位置auto lower = std::lower_bound(vec.begin(), vec.end(), 3);std::cout << "lower_bound: " << std::distance(vec.begin(), lower) << std::endl;//std::distance(vec.begin(), lower) 是一个 C++ 标准库中的算法函数//用于计算两个迭代器之间的距离//vec.begin() 是容器 vec 的起始迭代器//lower 是 std::lower_bound 函数返回的迭代器，指向第一个大于等于目标值的位置。//等价于lower - vec.begin() // 使用 upper_bound 查找第一个大于 3 的位置auto upper = std::upper_bound(vec.begin(), vec.end(), 3);std::cout << "upper_bound: " << std::distance(vec.begin(), upper) << std::endl;return 0;
}

4.蓝桥杯例题

二、最值查找

1. min和max函数

std::min 和 std::max 是 C++ 标准库中的两个算法函数，用于返回两个值中的最小值和最大值。它们在 <algorithm> 头文件中声明。时间复杂度为 O(n)

#include <iostream>
#include <algorithm>int main() {int a = 10;int b = 20;// 返回两个值中的较小值int min_val = std::min(a, b);std::cout << "最小值：" << min_val << std::endl;// 返回两个值中的较大值int max_val = std::max(a, b);std::cout << "最大值：" << max_val << std::endl;//也可以返回一个列表中最大最小的值,用大括号{}括起来std::cout << "列表中的最大值：" << std::max({1, 2, 3, 4, 5}) << std::endl;return 0;
}

2.min_element和max_element函数

std::min_element 和 std::max_element 是 C++ 标准库中的两个算法函数，用于在容器中查找最小值和最大值对应的迭代器。它们在 <algorithm> 头文件中声明。时间复杂度为 O(n)。
注意它返回的是迭代器,要的到返回的值需要*()

std::min_element(first, last)
std::max_element(first, last)
first 和last：表示要查找的范围的起始和结束迭代器（包含 first，但不包含 last）。[first, last)

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};// 返回容器中的最小值对应的迭代器auto min_it = std::min_element(vec.begin(), vec.end());std::cout << "最小值：" << *min_it << std::endl;// 返回容器中的最大值对应的迭代器auto max_it = std::max_element(vec.begin(), vec.end());std::cout << "最大值：" << *max_it << std::endl;return 0;
}

3.nth_element函数

std::nth_element 是 C++ 标准库中的一个算法函数，用于对容器中的元素进行部分排序，使得指定位置的元素处于排序后的正确位置。它在 <algorithm> 头文件中声明。

std::nth_element (first, nth, last)
std::nth_element 函数对范围 [first, last) 中的元素进行部分排序，使得迭代器 nth 指向的元素处于排序后的正确位置。
换句话说，nth 之前的元素都不大于 nth位置的元素，nth 之后的元素都不小于 nth 位置的元素。但是，nth 位置的元素不一定是整个范围中的第 nth 小的元素。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};// 将容器中的第5个元素置于正确的位置 ,排序后的容器第五个是正确位置的std::nth_element(vec.begin(), vec.begin() + 4, vec.end());// 输出排序后的结果std::cout << "第5个元素：" << vec[4] << std::endl;std::cout << "排序后的容器：" << std::endl;for (const auto& elem : vec) {std::cout << elem << " ";  //}std::cout << std::endl;return 0;
}

4.蓝桥杯例题

三、排序

1.sort函数

std::sort 是 C++ 标准库中的一个算法函数，用于对容器中的元素进行排序。它在 <algorithm> 头文件中声明。
first 和 last：表示要排序的范围的起始和结束迭代器（包含 first，但不包含 last）。
std::sort 函数对范围 [first, last) 中的元素执行排序操作。默认情况下，它使用 < 运算符来比较元素的大小。如果需要自定义排序规则，可以提供一个比较函数或者 lambda 函数作为额外参数。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};// 对容器中的元素进行排序std::sort(vec.begin(), vec.end());// 输出排序后的结果std::cout << "排序后的容器：" << std::endl;for (const auto& elem : vec) {std::cout << elem << " ";}std::cout << std::endl;return 0;
}

2.sort自定义比较函数,或lambda表达式(匿名函数)

如果需要自定义排序规则，可以通过提供一个比较函数或者 lambda 函数来告诉 std::sort 函数如何进行排序。

#include <iostream>
#include <vector>
#include <algorithm>// 自定义比较函数，按照元素的绝对值进行排序
bool compareAbsoluteValue(int a, int b) {return std::abs(a) < std::abs(b);
}int main() {std::vector<int> vec = {3, -1, 4, -6, 5, 9, -2, 6};// 使用自定义比较函数对容器中的元素进行排序std::sort(vec.begin(), vec.end(), compareAbsoluteValue);/* lambda表达式(匿名函数)std::sort(vec.begin(), vec.end(), [](int a, int b) {return std::abs(a) < std::abs(b);});*/// 输出排序后的结果std::cout << "排序后的容器：" << std::endl;for (const auto& elem : vec) {std::cout << elem << " ";}std::cout << std::endl;return 0;
}

3.蓝桥杯例题

四、全排列

1.next_permutation函数

std::next_permutation 是 C++ 标准库中的一个算法函数，用于生成给定序列的下一个排列。它在 <algorithm> 头文件中声明。

bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);
first 和 last：表示要处理的范围的起始和结束迭代器（包含 first，但不包含 last）。
std::next_permutation 函数会重新排列范围 [first, last) 中的元素，生成当前排列的下一个排列。如果存在下一个排列，则函数返回 true，否则返回 false。如果 first 和 last 之间的元素已经按字典序降序排列（即当前排列是最后一个排列），那么函数将重新排列这些元素为第一个排列，并返回 false。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 next_permutation 函数int main() {std::vector<int> vec = {1, 2, 3};// 打印初始排列std::cout << "初始排列: ";for (int num : vec) {std::cout << num << " ";}std::cout << std::endl;// 生成并打印下一个排列，直到没有下一个排列为止while (std::next_permutation(vec.begin(), vec.end())) {std::cout << "下一个排列: ";for (int num : vec) {std::cout << num << " ";}std::cout << std::endl;}return 0;
}

2. prev_permutation函数

std::prev_permutation 是 C++ 标准库中的一个算法函数，用于生成给定序列的上一个排列。它在 <algorithm> 头文件中声明。

bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
first 和 last：表示要处理的范围的起始和结束迭代器（包含 first，但不包含 last）。
std::prev_permutation 函数会重新排列范围 [first, last) 中的元素，生成当前排列的上一个排列。如果存在上一个排列，则函数返回 true，否则返回 false。如果 first 和 last 之间的元素已经按字典序升序排列（即当前排列是第一个排列），那么函数将重新排列这些元素为最后一个排列，并返回 false。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 prev_permutation 函数int main() {std::vector<int> vec = {3, 2, 1};// 打印初始排列std::cout << "初始排列: ";for (int num : vec) {std::cout << num << " ";}std::cout << std::endl;// 生成并打印上一个排列，直到没有上一个排列为止while (std::prev_permutation(vec.begin(), vec.end())) {std::cout << "上一个排列: ";for (int num : vec) {std::cout << num << " ";}std::cout << std::endl;}return 0;
}

五、大小写函数

1.islower,isupper函数

islower 和 isupper 是 C++ 标准库中的字符处理函数，用于检查字符是否为小写字母和大写字母。它在 <cctype> 头文件中声明。

int islower(int c);
c：表示要检查的字符，通常以整数形式传入。
islower 函数用于检查字符 c是否为小写字母。如果 c 是小写字母，则返回非零值（通常为 1），否则返回 0。

int isupper(int c);
c：表示要检查的字符，通常以整数形式传入。
isupper 函数用于检查字符 c是否为大写字母。如果 c 是大写字母，则返回非零值（通常为 1），否则返回 0。

#include <iostream>
#include <cctype> // 包含 islower 函数int main() {char c = 'a';// 检查字符 c 是否为小写字母if (islower(c)) {std::cout << c << " 是小写字母" << std::endl;} else {std::cout << c << " 不是小写字母" << std::endl;}// 检查字符 c 是否为大写字母if (isupper(c)) {std::cout << c << " 是大写字母" << std::endl;} else {std::cout << c << " 不是大写字母" << std::endl;}return 0;
}

2.tolower,toupper函数

tolower 和 toupper 是 C++ 标准库中的字符处理函数，用于将字符转换为小写和大写形式。它在 <cctype> 头文件中声明。

int tolower(int c);
c：表示要转换的字符，通常以整数形式传入。
tolower 函数用于将字符 c 转换为小写形式。如果c 是大写字母，则返回相应的小写字母；否则，返回 c 自身。
int toupper(int c);
c：表示要转换的字符，通常以整数形式传入。
toupper 函数用于将字符 c 转换为大写形式。如果 c是小写字母，则返回相应的大写字母；否则，返回 c 自身。

#include <iostream>
#include <cctype> // 包含 tolower 函数int main() {char c = 'A';char d = 'b';// 将字符 c 转换为小写形式char lowercase_c = tolower(c);std::cout << "字符 " << c << " 转换为小写形式为 " << lowercase_c << std::endl;// 将字符 d 转换为大写形式char uppercase_d = toupper(d);std::cout << "字符 " << d << " 转换为大写形式为 " << uppercase_d << std::endl;return 0;
}

六、其他库函数

1.memset 函数

memset 是 C/C++ 标准库中的一个函数，用于将一段内存区域的内容设置为指定的值。它在 <cstring> 头文件中声明。

memset 函数将指针 ptr 开始的连续 num 个字节的内存内容都设置为 value。
void* memset(void* ptr, int value, size_t num);
ptr：表示指向要填充的内存区域的指针。
value：表示要设置的值，以整数形式传入。
num：表示要设置的字节数。

#include <iostream>
#include <cstring> // 包含 memset 函数int main() {char str[] = "Hello, world!";int size = sizeof(str);// 将 str 数组的内容全部设置为 'A'memset(str, 'A', size);std::cout << str << std::endl; // 输出 "AAAAAAAAAAAAAA"return 0;
}

2.swap 函数

std::swap 是 C++ 标准库中的一个函数模板，用于交换两个值。它在 <algorithm> 头文件中声明。
std::swap 函数用于交换 a 和 b 两个值。它可以用于任何数据类型，包括基本数据类型（如整数、浮点数）和自定义类型（如类对象）。

#include <iostream>
#include <algorithm> // 包含 swap 函数int main() {int a = 10;int b = 20;// 交换 a 和 b 的值std::swap(a, b);std::cout << "a: " << a << std::endl; // 输出 "20"std::cout << "b: " << b << std::endl; // 输出 "10"return 0;
}

3.reverse 函数

std::reverse 是 C++ 标准库中的一个算法函数，用于反转容器中元素的顺序。它在 <algorithm> 头文件中声明。

void reverse(BidirectionalIterator first, BidirectionalIterator last);
first 和 last：表示要反转的范围的起始和结束迭代器（包含 first，但不包含 last）。
std::reverse 函数用于反转范围 [first, last) 中的元素的顺序。它逆序地重新排列容器中的元素，即将第一个元素与最后一个元素交换，第二个元素与倒数第二个元素交换，以此类推，直到中间位置。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 reverse 函数int main() {std::vector<int> vec = {1, 7, 3, 6, 5};// 反转容器中的元素顺序std::reverse(vec.begin(), vec.end());// 输出反转后的结果std::cout << "反转后的容器：" << std::endl;for (const auto& elem : vec) {std::cout << elem << " ";  //5 6 3 7 1}std::cout << std::endl;return 0;
}

4.unique 函数

std::unique 是 C++ 标准库中的一个算法函数，用于移除容器中相邻重复的元素，并返回指向新的逻辑结尾的迭代器。它在 <algorithm> 头文件中声明。

ForwardIterator unique(ForwardIterator first, ForwardIterator last);
first 和 last：表示要处理的范围的起始和结束迭代器（包含 first，但不包含 last）。
std::unique 函数用于移除范围 [first, last) 中相邻重复的元素，只保留每个不重复元素的第一个出现，并返回一个指向新的逻辑结尾的迭代器，指向不重复元素的下一个位置。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 unique 函数int main() {std::vector<int> vec = {1, 2, 2, 3, 6, 3, 3, 6, 6, 4, 5, 5};// 移除容器中相邻重复的元素auto new_end = std::unique(vec.begin(), vec.end());// 输出处理后的容器内容std::cout << "处理后的容器：" << std::endl;for (auto it = vec.begin(); it != new_end; ++it) {std::cout << *it << " "; //1 2 3 6 3 6 4 5}std::cout << std::endl;return 0;
}

---

总结

以上就是本章的介绍,唐怡佳继续加油!也希望大家都能取得好的成绩!