1. 算法刷题常用记录学习
1.1 sort排序
1.1.1 使用 std::greater 实现降序排序
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // std::greater
int main() {
std::vector<int> numbers = {1, 3, 5, 2, 4};
std::sort(numbers.begin(), numbers.end(), std::greater<int>());
// 字符串用 std::greater<std::string>()
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}
1.1.2 使用自定义比较函数（cmp）实现降序排序
#include <iostream>
#include <vector>
#include <algorithm>
// 自定义比较函数
bool cmp(int a, int b) {
return a > b;
}
int main() {
std::vector<int> numbers = {1, 3, 5, 2, 4};
std::sort(numbers.begin(), numbers.end(), cmp);
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}
1.1.3 使用 Lambda 表达式按降序排序
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
std::vector<int> numbers = {5, 2, 9, 1, 5, 6};
// 使用 Lambda 表达式按降序排序
std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
return a > b;
});
for(int num : numbers) {
std::cout << num << " "; // 输出：9 6 5 5 2 1
}
return 0;
}
1.1.4 tuble按第三个元素降序排序
#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>
// 自定义比较函数，根据 tuple 的第三个元素（double）进行降序排序
bool compareTuples(const std::tuple<int, std::string, double>& a,
const std::tuple<int, std::string, double>& b) {
return std::get<2>(a) > std::get<2>(b); // 按第三个元素降序排序
}
int main() {
std::vector<std::tuple<int, std::string, double>> items = {
{2, "apple", 3.5},
{1, "banana", 2.0},
{2, "orange", 4.1},
{1, "grape", 1.2}
};
std::sort(items.begin(), items.end(), compareTuples);
for (const auto& item : items) {
std::cout << std::get<0>(item) << ", "
<< std::get<1>(item) << ", "
<< std::get<2>(item) << std::endl;
}
return 0;
}
1.2 删除空格
一行代码删除空格
str.erase(remove(str.begin(), str.end(), ' '), str.end());
1.3 数组去重
两行代码去重
#include <algorithm>
#include <vector>
std::sort(vec.begin(), vec.end());
vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
1.4 求向量或数组中的最大值和最小值
int maxVal = *max_element(vec.begin(), vec.end());
int minVal = *min_element(vec.begin(), vec.end());
1.5 计算数组元素的总和
int sum = accumulate(vec.begin(), vec.end(), 0); // 第三个参数是初始值
1.6 字符串转为小写或大写
transform(str.begin(), str.end(), str.begin(), ::tolower); // 转为小写
transform(str.begin(), str.end(), str.begin(), ::toupper); // 转为大写
1.7 查找元素是否在容器中
bool found = find(vec.begin(), vec.end(), target) != vec.end();
1.8 删除数组中的所有指定元素
vec.erase(remove(vec.begin(), vec.end(), value), vec.end());
1.9 数组反转
reverse(vec.begin(), vec.end());
1.10 字符串拆分成单词
#include <sstream>
istringstream iss(str);
vector<string> words((istream_iterator<string>(iss)), istream_iterator<string>());
istream_iterator<string>是一个输入迭代器，专门用于从输入流中读取类型为string的数据- 当创建
istream_iterator<string>(iss)时，它会开始从istringstream流中读取每一个由空白字符（空格、制表符、换行符等）分隔的字符串（即单词） istream_iterator<string>()是一个默认构造的迭代器，用来表示流的结束位置。
1.11 计算二进制数中的1
int count = __builtin_popcount(n);
1.12 交换两个变量的值
a ^= b; b ^= a; a ^= b;
1.13 stoi
stoi 是 C++11 引入的一个函数，用于将字符串转换为整数。这个函数在 <string> 头文件中定义。虽然它的主要功能是将字符串转换为整数，但它的功能相当灵活，可以处理不同进制的数字和不同的字符串格式。
1.13.1 函数原型
int stoi(const std::string& str, std::size_t* pos = nullptr, int base = 10);
1.13.2 参数解释
-
str (const std::string& 或 const std::wstring&)：
- 要转换的字符串。
- 这个参数是必需的。
-
pos (std::size_t*，默认值是 nullptr)：
- 可选参数，用于存储第一个无法转换的字符的索引。
- 如果你对转换后的字符串的末尾位置感兴趣，可以传递一个
std::size_t指针来获取它的值。如果不需要，可以忽略这个参数或传递nullptr。 - 例如，如果你有字符串
"123abc"，并且你使用stoi进行转换，pos将指向'a'的位置。
-
base (int，默认值是 10)：
- 可选参数，用于指定字符串表示的数字的进制。
- 默认值是 10，表示将字符串当作十进制数进行转换。
- 你可以设置为 2（表示二进制）、8（表示八进制）、16（表示十六进制）等。
1.13.3 示例
假设你有一个表示十六进制数的字符串 "1A3F"，并希望将其转换为整数：
#include <iostream>
#include <string>
int main() {
std::string hexString = "1A3F";
int number = std::stoi(hexString, nullptr, 16);
std::cout << "The decimal value of hex " << hexString << " is " << number << std::endl;
return 0;
}
hexString: 是"1A3F"，表示十六进制的数字。nullptr: 这里我们不关心字符串转换后的末尾位置，所以传递nullptr。16: 这个参数指定了字符串中的数字是以十六进制表示的。
输出结果为：
The decimal value of hex 1A3F is 6719
即 "1A3F" 对应的十进制数字是 6719。
1.14 stringstream
std::stringstream 是 C++ 标准库中的一个类，属于 <sstream> 头文件。它主要用于将数据流与字符串进行绑定，使得我们能够像操作 std::cin 和 std::cout 那样对字符串进行输入和输出操作。
1.14.1 关键概念：
-
字符串流类：
std::stringstream是一种流类，可以对字符串进行读写操作。它的操作类似于std::cin和std::cout，但作用对象是字符串而不是标准输入输出。
-
基本用法：
- 输出到字符串流：你可以使用
<<运算符将数据写入std::stringstream对象中，类似于将数据输出到std::cout。 - 从字符串流读取：你可以使用
>>运算符从std::stringstream对象中读取数据，类似于从std::cin读取输入。
- 输出到字符串流：你可以使用
1.14.2 示例代码：
std::string data = "123 456.789 Hello";
std::stringstream ss(data);
int integerPart;
double doublePart;
std::string textPart;
ss >> integerPart >> doublePart >> textPart;
ss >> integerPart 会从 ss 中提取出第一个能够被解释为整数的部分，也就是 123。然后，ss >> doublePart 会提取下一个能够被解释为浮点数的部分，也就是 456.789。最后，ss >> textPart 提取剩下的字符串部分 "Hello"。
1.14.3 常见用法：
- 字符串解析：
std::stringstream常用于解析字符串，特别是当字符串中包含混合类型的数据（如整数和字符串）时。 - 构建字符串：它也可以用于通过组合不同类型的数据来构建字符串。
1.14.4 详细解释：
-
构造函数：
std::stringstream有两个常用的构造函数：- 默认构造函数：
std::stringstream ss;创建一个空的字符串流。 - 带初始字符串的构造函数：
std::stringstream ss("initial string");创建一个包含初始字符串的字符串流。
- 默认构造函数：
-
设置和获取字符串：
- 使用
str()方法获取当前流中的字符串：std::string s = ss.str(); - 使用
str("new string")设置或重置流中的字符串。
- 使用
-
清空流：
- 使用
clear()方法清除错误状态，但不清除内容。 - 使用
str("")来重置流内容，使流恢复到空的状态。
- 使用
-
流状态：在读取时，如果流中没有更多数据可供提取，流的状态会变为“失败”（
failbit）。因此在读取数据时，通常会检查流的状态，以确定是否读取成功。
1.14.5 示例扩展：
#include <iostream>
#include <sstream>
#include <string>
int main() {
std::string data = "123 apple 456 banana 789 cherry";
std::stringstream ss(data);
int num;
std::string fruit;
while (ss >> num >> fruit) {
std::cout << "Number: " << num << ", Fruit: " << fruit << std::endl;
}
return 0;
}
/*输出：
Number: 123, Fruit: apple
Number: 456, Fruit: banana
Number: 789, Fruit: cherry
*/
1.15 二分查找模板
1.15.1 寻找某个数的左边界
int l = -1, r = n;
while (l + 1 != r) {
int mid = l + r >> 1;
if (q[mid] < target) l = mid; // 查找第一个大于等于 target 的位置
else r = mid; // q[mid] >= target
}
if (r != n && q[r] == target) return r; // 确认 r 在数组范围内且 q[r] 等于 target
return -1; // 未找到
1.15.2 寻找某个数的右边界
int l = -1, r = n;
while (l + 1 != r) {
int mid = l + r >> 1;
if (q[mid] <= target) l = mid; // 查找最后一个小于等于 target 的位置
else r = mid; // q[mid] > target
}
if (l != -1 && q[l] == target) return l; // 确认 l 在数组范围内且 q[l] 等于 target
return -1; // 未找到
1.15.3 通用二分模板
int l = 初始下界 - 1; // 防止是查找的目标是边界
int r = 初始上界 + 1; // 防止是查找的目标是边界
while (l + 1 != r) {
int mid = l + r >> 1;
if (check(mid)) { // check函数找最小值满足返回true
r = mid; // 尝试更小的值
} else {
l = mid; // mid 太小了，需要更大的值
}
}
// 最后返回 r，因为 r 是第一个使 check(r) 为 true 的值，如果是找最后一个就返回改变check函数返回l
return r;
考虑以下三个点即可
- check函数相当于选择分界线，l是分界线的左边，r是分界线的右边；
- 考虑满足check条件的是需要更小还是更大，更小就r = mid，更大就l = mid；
- 如果需要更小就return r，更大就return l
1.16 滑动窗口模板
滑动窗口常用于处理一维数组或字符串中的子数组问题。
1.16.1 最长模板
左右指针（LR）在起始位置，R指针逐步向右循环滑动，在每次滑动的过程中，如果滑动窗口内的元素满足滑动窗口的需求，R指针不断向右滑动扩大窗口，并不断更新最优结果；如果窗内元素不满足条件，L指针不断向右缩小窗口，在此过程中并不断更新结果，直到R到达结尾
初始化 left，right，result，bestResult
while("右指针没有到结尾"){
窗口扩大，加入right对应元素，更新当前result
while("result不满足要求"){
窗口缩小，移除left对应元素，left右移
}
更新最优结果bestResult
right++;
}
返回bestResult
1.16.2 最短模板
实现思路：
左右指针（LR）初始在起始点，R逐步向右滑动，在每次滑动的过程中，如果窗口内的元素满足条件，L向右缩小窗口，并不断更新最小的结果，如果窗口内的元素不满足条件，R不断向右扩大窗口，直到R到达字符串的结尾
初始化 left，right，result，bestResult
while("右指针没有到结尾"){
窗口扩大，加入right对应元素，更新当前result
while("result满足要求"){
更新最优结果bestResult
窗口缩小，移除left对应元素，left右移
}
right++;
}
返回bestResult
1.17 回溯模板
组合问题，子集问题，全排列问题
void backtracking(参数) {
if (终止条件) { /* 子集问题不考虑终止，每个节点都需要收集结果 */
存放结果;
return;
}
/* 组合和子集问题考虑startIndex */
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表);
回溯，撤销处理结果
}
}
1.17.1 示例
eg:给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明： 所有数字（包括目标数）都是正整数。解集不能包含重复的组合。
- 示例 1:
- 输入: candidates = [10,1,2,7,6,1,5], target = 8,
- 所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
if (sum == target) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) { // 或者直接i > startIndex && candidates[i] == candidates[i - 1],这样需要保证数组有序
continue;
}
sum += candidates[i];
path.push_back(candidates[i]);
used[i] = true;
backtracking(candidates, target, sum, i + 1, used);
used[i] = false;
sum -= candidates[i];
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
vector<bool> used(candidates.size(), false);
sort(candidates.begin(), candidates.end());
backtracking(candidates, target, 0, 0, used);
return result;
}
};
1.17.2 注意的点
-
startIndex 处理的是当前层的起始位置（组合问题、子集问题）
- 当前值如果上一层用过 ，下一层不能再用，传参i + 1
- 当前值如果上一层用过 ，下一层也能再用，传参i
- 全排列问题不使用startIndex
-
数组中有重复数字
-
如果数组有序，直接通过下面式子，在 “层” 上去重
if (i > startIndex && candidates[i] == candidates[i - 1]) continue; -
如果数组无序，需要使用used数组，记录哪是使用过的数字
如果 “树枝” 上发现当前值与之前值相同，used对应的值为1，可以重复选，因为"树枝"是递归，选择后 面的元素，eg: 1 1 2 3 target = 4 startIndex在第1个1时，可以选择 1 1 2
如果 “层” 上发现当前值与之前值相同，used对应的值为0，不可以重复选，因为"层"是遍历，前面的值选择后面的值与当前值选择后面的值结果是一样的，eg: 1 1 2 3 target = 4 startIndex在第2个1时与第1个1结果都有 1 3,
-
unordered_set去重，在"层"上定义unordered_set，只负责本层，不需要回溯，因为每一层都会重新定义，可以通过
uset.find(nums[i]) != uset.end()判断之前是否有使用过
-
-
全排列问题
- 全排列问题需要考虑之前的元素，但当前元素不能重复使用，eg: 1 2 3全排列，当前值为2时，2 1 3也是一种排列，但是当前值2只能用一次，也就是没有 2 2 2，类似这种，所以使用used数组，如果当前元素用过就跳过。
if (used[i] == true) continue;
- 全排列问题需要考虑之前的元素，但当前元素不能重复使用，eg: 1 2 3全排列，当前值为2时，2 1 3也是一种排列，但是当前值2只能用一次，也就是没有 2 2 2，类似这种，所以使用used数组，如果当前元素用过就跳过。
扫一扫
3170
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
