蓝桥杯常用stl（c++）

map

时间复杂度：O(logn)
底层：红黑树
存储一组键值对，每个键都是唯一的，根据键自动进行排序，可以通过键快速查找对应的值
insert：插入元素，O(logn)
erase：删除元素，O(logn)
find：查找元素，O(logn)
count：统计元素个数，判断key是否存在，O(logn)
size：返回元素个数，O(1)
begin：返回指向容器起始位置的迭代器，O(1)
end：返回指向容器末尾位置的迭代器，O(1)
clear：清空容器，O(1)
empty：判断容器是否为空，O(1)
lower_bound：返回指向第一个大于等于指定键的元素位置，O(logn)
upper_bound：返回指向第一个大于指定键的元素位置，O(logn)

#include
#include
using namespace std;

int main(){
	map<int, string> mp;
	mp.insert(make_pair(3, "老铁666"));
	mp.insert({2, "小屁孩"});
	mp.insert({7, "星期天"});
	
	cout<<mp.lower_bound(2) -> second<<endl;
	
	cout<<mp[3]<<endl;
	
	for(auto &it : mp){
		cout<<it.first<<" "<<it.second<<endl;
	}
	
	mp.erase(2);
	
	if(!mp.count(2)){
		cout<<"2不存在了";
	}
	return 0;
}

multimap

可以允许存储多个具有相同键的键值对

unordered_map

底层：哈希函数
无序的，速度更快

pair

表示一对值的组合，第一个值p.first，第二个值p.second，默认根据按照第一个值从小到大排序
pair p;

int main(){
	vector<pair<int, int>> p;
	p.push_back(make_pair(1, 3));
	p.push_back(make_pair(4, 2));
	p.push_back({5, 7});
	cout<<p.size();
	return 0;
}

list

双向链表容器，很少用，一般都是数组模拟链表

stack

栈，后进先出，遍历的话只能一个一个弹出来
push(x)：栈顶插入元素x
pop()：弹出栈顶
top()：返回栈顶元素
empty()：检查栈是否为空
size()：返回栈中元素的个数

queue

队列，先进先出
push(x)：队尾插入元素x
pop()：弹出队首元素
front()：返回队首元素
back()：返回队尾元素
empty()：检查队列是否为空
size()：返回队列中元素的个数

priority_queue

优先队列，默认大根堆，顶部最大，树形结构
push(x)：插入元素x
pop()：弹出顶部元素
top()：返回顶部元素
empty()：检查队列是否为空
size()：返回队列中元素的个数

//清空堆
priority_queue<int>().swap(q);
//或
while (!q.empty()) {
    q.pop();
}

//小根堆
priority_queue<int, vector<int>, greater<int>> q;

//重载，小根堆
struct cmp{
	bool operator () (int a, int b){
		return a > b;
	}
}; 

int main(){
	priority_queue<int, vector<int>, cmp> q;
	for(int i = 0; i < 5; i++) q.push(i);
	cout<<q.top();
	return 0;
}

deque

双端队列
push_back(x)：尾巴插入元素x
push_front(x)：头部插入元素x
pop_back()：弹出尾巴元素
pop_front()：弹出头部元素
front()：返回头部元素
back()：返回尾部元素
empty()：检查是否为空
size()：返回元素个数
clear()：情况所有元素

vector

动态数组容器
push_back(x)：将元素x添加到末尾
pop_back()：删除末尾元素，要保证非空
begin()、end()：指定第一个元素和最后一个元素之后位置的迭代器

int main(){
	vector<int> v = {30, 20, 60, 10, 20, 20};
	//排序 
	sort(v.begin(), v.end());
	//去重
	auto last = unique(v.begin(), v.end());
	v.erase(last, v.end()); 
	for(auto it = v.begin(); it != v.end(); it++){
		cout<<*it<<endl;
	}
	return 0;
}

set

存储一组唯一的元素，默认按照升序排序，可以用结构体重载()
insert(x)：插入元素
erase(x)：删除元素
find(x)：查找元素，返回一个迭代器
lower_bound(x)：返回第一个大于等于x的迭代器
upper_bound(x)：返回第一个大于x的迭代器
size()：返回元素数量
empty()：检查是否为空
clear()：清空集合
begin()、end()：起始和末尾迭代器
rbegin()、rend()：末尾和起始的逆向迭代器
swap()：交换两个集合

//重载
struct cmp{
	bool operator () (const int &a, const int &b) const {
		return a > b;
	}
};

int main(){
	//降序排列 
	set<int, greater<int>> s;
	
	//仿函数，降序排列
	set<int, cmp> ss; 
}

multiset

多重集合，允许存储重复元素
erase(x)：把x全部删掉
s.erase(s.find(x))：只删除第一个x

unordered_set

无序集合