stl常用函数

万能头文件

#include <bits/stdc++.h>
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);

C++常用函数

#include <algorithm>

sort(myvector.begin(), myvector.begin() + 4);//默认采用快速排序
merge(a, a + 5, b, b + 6,c.begin());//将两个有序数组：a数组和b数组，合并成新的有序数组存入c数组
auto it = find(myvector.begin(), myvector.end(), 30);//find查找成功，返回找到的第一个元素的迭代器，失败则返回最后一个元素的迭代器

vector<int> A{ 1,2,3,4,8,12,18,1,2,3 };
int B[] = { 1,2,3 };
auto it = search(A.begin(), A.end(), B, B + 3);//查找B序列在A中第一次出现的位置

//默认使用二分查找，因此必须是有序的序列
int a[5] = { 1,2,3,4,5 };
int *p = lower_bound(a, a + 5, 3);//从 a 数组中找到第一个不小于 3 的元素
int *p = upper_bound(a, a + 5, 3);//从 a 数组中找到第一个大于 3 的元素

s[0] = 0;
partial_sum(nums.begin(), nums.end(), s + 1); // 计算 nums 的前缀和，存入数组s中

//将字符s[i]进行大小写转换
s[i]=toupper(s[i]);
s[i]=tolower(s[i]);

#include<numeric>	
int sum = accumulate(nums.begin(), nums.end(), 0)；//累加num数组的值

#include<numeric>   	
iota(v.begin(),v.end(),1);//使v初始化，从1开始递增赋值

#include <algorithm>
max_element(nums.begin(), nums.end());  //不带*：元素最大值的地址
*max_element(nums.begin(), nums.end());  //带*:元素最大值
int ans = ___gcd(a,b)//库函数求a b最大公约数

string常用函数

#include <string>

string s1();  // s1 = ""
string s2("Hello");  // s2 = "Hello"
string s3(4, 'K');  // s3 = "KKKK"
s2.append(s3);  // s2 = "HelloKKKK"
int n = s1.compare(s2);//小于 0 表示当前的字符串小；等于 0 表示两个字符串相等；大于 0 表示另一个字符串小。
string s4 = s2.substr(2,4); //s4 = "lloK" 从下表2开始的4个字符
s1.swap(s2);//交换s1和s2的字符串

vector容器常用函数（动态数组）

#include <vector>
using namespace std;

vector<double> values;
vector<double> values(20);//20个元素
vector<double> values(20, 1.0);//20个元素，默认值为1.0
vector<int> value1{2, 3, 5, 7, 11, 13, 17, 19};//直接赋值
vector<int> value2(begin(value1),begin(value1)+3);//value2={2,3,5}
int n = values.size();//返回元素个数
bool is = values.empty(); //返回容器是否为空
values.push_back(x);//尾部插入一个元素x
values.pop_back();//尾部删除一个元素
values.emplace_back(x);//尾部插入一个元素x，速度比push_back快
values.erase(values.begin() + 2);//删除指定位置的元素（下标为2）
swap(values[1],values[4]);//交换下标1和4的元素

list容器常用函数（双向链表）

#include <list>
using namespace std;

list<int> values;
list<int> values(10);
list<int> values(10, 5);
int &first = mylist.front();//返回头节点
int &last = mylist.back();//返回尾节点
int n = values.size();//返回节点个数
bool is = values.empty(); //返回容器是否为空
values.push_front(x);//头部插入一个节点x
values.pop_front();//头部删除一个节点
values.push_back(x);//尾部插入一个节点x
values.pop_back();//尾部删除一个节点
values.emplace_front(x);//头部插入一个节点x，速度比push_front快
values.emplace_back(x);//尾部插入一个节点x，速度比push_back快
values.reverse();//将链表节点反转
list<int> mylist1{ 1,2,3,4 }, mylist2{10,20,30};
mylist2.splice(mylist2.end(), mylist1, mylist1.begin(), mylist1.end());//将mylist1的节点移动到mylist2之后
//mylist1:
//mylist2:1 3 4 2 10 20 30 
values.erase(values.begin()+2);//删除链表第2个节点
values.remove('c');//删除元素值为c的节点
values.unique();//删除链表中重复的元素
for (auto it = values.begin(); it != values.end(); ++it) {//遍历链表
	cout<<*it;
}

pair键值对

#include <utility>      // pair
#include <string>       // string
using namespace std;

pair <string, string> pair1;
pair <string, int> pair1("nums", 20);
pair1.first = "name";
pair1.second = "cashmaker";

map容器常用函数

#include <map>
using namespace std;

map<int, int> mymap;
mymap.insert({key,value});//map会默认根据value的值升序排序,key的值唯一
mymap.emplace(key,value);//插入，但速度更快
mymap.erase(key);//删除key对应的键值对
mymap.count(key);//返回1表示有这个key，0表示没有
mymap.find(key);//找到返回该键值对的迭代器，没找到返回end()方法一样的迭代器
if(mymap.find(x) != mymap.end())//等同于键x存在于map中
auto it = maymap.find(x);
int a = it->first, b = it->second, c = mymap[x]; //a和c相等	
mymap.at(key);//返回key对应的值，查找失败会报异常
mymap.lower_bound(key);//返回第一个大于等于key的键值对的迭代器，相当于 [ 闭区间
mymap.upper_bound(key);//返回第一个大于key的键值对的迭代器，相当于 ( 开区间

//multimap 也有相同的方法，但可以内部的元素不是唯一的

set容器常用函数

#include <set>
using namespace std;

set<string> myset;//默认升序排序，值唯一
myset.insert(x);//插入一个值
myset.emplace(x);//速度比insert快
myset.erase(x);//删除一个值
myset.count(x);//返回1表示有这个元素，0表示没有
myset.find(x);//找到返回该键值对的迭代器，没找到返回end()方法一样的迭代器
myset.lower_bound(x);//返回第一个大于等于x的键值对的迭代器，相当于 [ 闭区间
myset.upper_bound(x);//返回第一个大于x的键值对的迭代器，相当于 ( 开区间

//multiset 也有相同的方法，但可以内部的元素不是唯一的

unordered_map 容器常用函数

#include <unordered_map>
using namespace std;

//unordered_map与map相比，区别是unordered_map是无序的
unordered_map<int, int> mymap;
mymap.insert({key,value});//map会默认根据value的值升序排序,key的值唯一
mymap.emplace(key,value);//插入，但速度更快
mymap.erase(key);//删除key对应的键值对
mymap.find(key);//找到返回该键值对的迭代器，没找到返回end()方法一样的迭代器
if(mymap.find(x) != mymap.end())//等同于键x存在于map中
auto it = maymap.find(x);
int a = it->first, b = it->second, c = mymap[x]; //a和c相等	
mymap.at(key);//返回key对应的值，查找失败会报异常

unordered_set容器常用函数

#include <set>
using namespace std;

unordered_set<string> myset;//默认升序排序，值唯一
myset.insert(x);//插入一个值
myset.emplace(x);//速度比insert快
myset.erase(x);//删除一个值
myset.find(x);//找到返回该键值对的迭代器，没找到返回end()方法一样的迭代器

//multiset 也有相同的方法，但可以内部的元素不是唯一的

stack容器常用函数

#include <stack>
using namespace std;

stack<int> values;
values.empty(); //返回true或false
values.top();//返回栈顶元素的引用
values.push(x);//将元素x压入栈顶
values.pop();//弹出栈顶元素
values.emplace(x);//在栈顶生成一个x

queue容器常用函数

#include <queue>
using namespace std;

queue<int> values;
values.empty(); //返回true或false
values.front();//返回队首元素的引用
values.back();//返回队尾元素的引用
values.push(x);//在队尾添加元素x
values.pop();//弹出队首元素
values.emplace(x);//在队尾添加元素x

priority_queue容器常用函数

#include <queue>
using namespace std;

//优先队列中的元素是经过排序的，默认为降序
priority_queue<int> values;
priority_queue<int, vector<int>, greater<int>> heap;//小顶堆
priority_queue<int, vector<int>, less<int>> heap;//大顶堆
values.empty(); //返回true或false
values.push(x);//在队尾添加元素x
values.top();//返回队首元素的引用
values.pop();//弹出队首元素
values.emplace(x);//在队尾添加元素x