作者:LogM
algorithm
#include
min(a, b, comp); //取最小
max(a, b, comp);
min({a,b,c,d}, comp); //initializer_list
max({a,b,c,d}, comp);
*min_element(v.begin(), v.end(), comp); //数组取最小值
*max_element(v.begin(), v.end(), comp);
swap(a, b); // 交换
reverse(v.begin(), v.end()); //翻转
sort(v1.begin(), v1.end(), comp); //不稳定排序
stable_sort(v1.begin(), v1.end(), comp); //稳定排序
//comp函数举例
bool cmp_less(const int& a, const int& b) {
return a < b;
}
iter = find(v1.begin(), v1.end(), elem); //查找等于elem的元素
iter = search(v1.begin(), v1.end(), v2.begin(), v2.end()); //在v1中查找是否有区间包含v2,若没找到,返回v1.end()
lower_bound(v1.begin(), v1.end(), elem); //数组已排序,返回指向首个不小于elem的迭代器
upper_bound(v1.begin(), v1.end(), elem); //数组已排序,返回指向首个大于elem的迭代器
binary_search(v1.begin(), v1.end(), elem); //数组已排序,返回是否找到
迭代器
begin() / end(); //迭代
rbegin() / rend(); //反向迭代
cbegin() / cend(); //const迭代
crbegin() / crend(); //const反向迭代
//冒号遍历,基于迭代器实现,但遍历过程中insert和erase将引发无定义的行为,
//不能修改set和map的key等本身无法修改的元素
for (auto v:vec); //冒号遍历(只读)
for (auto& v:vec); //冒号遍历(读写)
iter = set1.erase(iter); //迭代过程中的安全erase
string
#include
string s1("hello"); //与下一行效果相同
string s1 = "hello";
string s1(4, '='); //生成4个'='组成的字符串
string s1(s2, 0, s2.size()); //拷贝另一个字符串的某个区间初始化
s1.clear(); //清空
s1.size(); //返回字符串长度,与下一行效果相同(不计'\0')
s1.length();
s1.empty(); //是否为空
s1.c_str(); //返回const char*形式
s1.substr(0, s1.size()); //返回指定区间内的子串,深拷贝
s1.append(s2, 0, s2.size()); //字符串后接另一个字符串的某个区间
to_string(100); //数值型转字符串
stoi("100"); //字符串转整型
stod("0.1"); //字符串转浮点型
vector
#include
vector v1 = v2; //深拷贝构造
vector v1 = {0,1,2,3}; //initializer_list初始化
vector v1(v2.begin(), v2.end()); //vector或array初始化
vector v1(7); //初始化有7个元素的vector
vector v1(7, 3) //初始化有7个3的vector
vector v1(r, vector(c, 0)) //初始化r行c列全为0的矩阵
v1.clear(); //清空
v1.size(); //返回元素数量
v1.empty(); //是否为空
v1.front(); //访问第一个元素
v1.back(); //访问最后一个元素
v1.push_back(100); //末尾插入元素
v1.pop_back(); //清除末尾元素
iter = v1.insert(v1.begin(), 100); //在vector最前面插入100
iter = v1.insert(v1.begin(), v2.begin(), v2.end()); //插入另一个数组
iter = v1.erase(v1.begin()+2); //erase一个数
iter = v1.erase(v1.begin()+2, v1.begin()+5); //erase一个区间
stack
#include
s1.clear(); //清空
s1.size(); //返回元素数量
s1.empty(); //是否为空
s1.top(); //返回栈顶元素
s1.push(100); //压栈
s1.pop(); //弹栈
queue/deque
#include
#include
q1.clear(); //清空
q1.size(); //返回元素数量
q1.empty(); //是否为空
q1.front(); //返回第一个元素
q1.back(); //返回最后一个元素
q1.push_front(100); //首位插入100
q1.push_back(100); //末位插入100
q1.pop_front(); //弹出第一个元素
q1.pop_back(); //弹出最后一个元素
优先级队列
//使用堆实现,建堆O(n),插入O(logn),删除O(logn),查找同vector
#include
priority_queue, less> maxQ; //大顶堆
priority_queue, greater> minQ; //小顶堆
priority_queue q1(less(), v1); //用v1初始化大顶堆
q1.clear(); //清空
q1.size(); //返回元素数量
q1.empty(); //是否为空
q1.top(); //返回堆顶元素
q1.push(100); //压入堆
q1.pop(); //弹出堆顶
//自定义比较函数Comp类的写法
struct CompLess {
bool operator() (const int a, const int b) {
return a < b;
}
};
//另一种建heap的方式
#include
std::make_heap(v.begin(), v.end(), comp); //建最大堆,v.front()为最大元素
v.push_back(6);
std::push_heap(v.begin(), v.end()); //其他部分为最大堆,末尾元素为新插入,进行上滤
std::pop_heap(v.begin(), v.end(), comp); //堆顶与堆底交换,然后下滤
v.pop_back()
pair
#include
pair p1(1, "Tom"); //生成一个pair
pair(1, "Tom"); //与下两行效果相同,类型由用户指定
pair(1, "Tom"); //与上一行效果相同,编译器判断变量类型
make_pair(1, "Tom"); //与上一行效果相同,编译器判断变量类型
p1.first;
p1.second;
set/multiset
//基于红黑树实现,有自动排序,插入O(logn),查找O(logn),删除O(logn)
//也导致无法直接修改set中的元素,只能先删除再插入
#include
#include
set> c1(c2); //深拷贝构造
set> c1(c2.begin(), c2.end());
set> c1(c2.begin(), c2.end(), comp); //迭代器返回的元素依次排序
c1.clear(); //清空
c1.size(); //返回元素数量
c1.empty(); //是否为空
c1.count(elem); //返回elem的count,可以用于判断set中是否有elem
c1.find(elem); //返回指向elem的迭代器,用"!=c1.end()"判断是否找到
c1.lower_bound(elem); //返回指向首个不小于elem的迭代器
c1.upper_bound(elem); //返回指向首个大于elem的迭代器
c1.insert(elem); //插入单个elem
c1.insert(c2.begin(), c2.end()); //插入另一个set的某个区间
c1.erase(elem); //返回被移除的元素的数量
c1.erase(iter); //清除iter指向的元素
c1.erase(c1.begin()+2, c1.begin()+5); //清除某个区间
unordered_set/unordered_multiset
//基于哈希表实现,插入O(n),查找O(n),删除O(n)
//代价占用内存比set/multiset略大一点点,内部元素不排序
#include
//大部分函数同set/multiset
//由于内部元素不排序,不能使用lower_bound和upper_bound
map/multimap
//基于红黑树实现,依据key自动排序,插入O(logn),查找O(logn),删除O(logn)
//也导致无法直接修改map中的元素,只能先删除再插入
#include
map m1 = {{2015, "Tom"}, {2016, "Jim"}}; //构造函数
m1.clear(); //清空
m1.size(); //返回元素数量
m1.empty(); //是否为空
m1.at[2015] = "Tom"; //取值,会检查key是否存在
m1[2015] = "Tom"; //若key存在则修改value,若不存在则创建
m1.count(key); //返回相应key的count,可以用于判断map中是否存在该key
iter = m1.find(key); //返回指向key的迭代器,用"!=m1.end()"判断是否找到
c1.lower_bound(key); //返回指向首个不小于key的迭代器
c1.upper_bound(key); //返回指向首个大于key的迭代器
m1.insert(make_pair(2015, "Tom")); //使用pair插入
m1.insert(pair(2015, "Tom"));
m1.insert({2015, "Tom"}); //initializer_list插入
m1.erase(key); //返回被移除的元素的数量
m1.erase(iter); //清除iter指向的元素
m1.erase(m1.begin()+2, m1.begin()+5); //清除某个区间
unordered_map/unordered_multimap
//基于哈希表实现,插入O(n),查找O(n),删除O(n)
//代价占用内存比map/multimap略大一点点,内部元素不排序
#include
//大部分函数同map/multimap
//由于内部元素不排序,不能使用lower_bound和upper_bound
list
list l1 = l2; //深拷贝构造
list l1 = {0,1,2,3}; //initializer_list初始化
list l1(l2.begin(), l2.end());
list l1(7); //初始化有7个元素的list
list l1(7, 3) //初始化有7个3的list
l1.clear(); //清空
l1.size(); //返回元素数量
l1.empty(); //是否为空
l1.front(); //访问第一个元素
l1.back(); //访问最后一个元素
l1.push_back(100); //末尾插入元素
l1.pop_back(); //清除末尾元素
iter = l1.insert(l1.begin(), 100); //在vector最前面插入100
iter = l1.insert(l1.begin(), l2.begin(), l2.end()); //插入另一个数组
iter = l1.erase(l1.begin()+2); //erase一个数
iter = l1.erase(l1.begin()+2, l1.begin()+5); //erase一个区间
基础输入输出
# include
std::string str;
std::getline(std::cin, str); //会把'\n'去除
std::getline(std::cin, str, ' '); //设置分隔符,此时将空格视为一行的结束,'\n'会被读入
/*
立即在空白符分隔输入后使用时,例如在 int n; std::cin >> n; 后, getline 会用 operator>> 消耗掉留在输入流上的换行符,并立即返回。
常用解决方案是在切换到面向行输入前,用 cin.ignore(std::numeric_limits<:streamsize>::max(), '\n'); 忽略输入行上所有剩下的字符。
*/
匿名函数
sort(v.begin(), v.end(),
[](const int& a, const int& b) {
return a < b;
});