基础语法——STL容器、常用库函数

一、Vector

Vector是变长数组，支持随机访问，不支持在任意位置O（1）插入，为了保证效率，元素的增删一般应在末尾进行。

#include<iostream>
#include<vector> //头文件 
using namespace std;
struct rec{
		int x,y;
	}; //自定义结构体 
int main(){
	vector<int> a; //定义一个长度动态变化的int数组 
	vector<int> b[233]; //定义一个第一位长度233，第二维长度动态变化的int数组 
	vector<rec> c; //自定义结构体类型也可以保存在vector中 
	a.size(); //返回数组实际大小，O（1） 
	a.empty(); //返回一个bool值，表示数组是否为空，O（1） 
	a.clear(); //清空数组中的值,O(1)
	vector<int>::iterator it = a.begin(); //定义一个迭代器，迭代器可以看成指针 
	vector<int> a({1,2,3}); //vector数组初始化 
	for(int i = 0;i = a.size();i ++ ){
		cout << a[i] << " ";
	} //一、数组方式遍历vectore数组
	for(vector<int>::iterator i = a.begin();i < a.end();i ++ ){
		cout << *i << " ";
	} //二、迭代器方式遍历vector数组
	for(int x : a){
		cout << x <<" "; 
	} //三、范围遍历 
	cout << a.front() << a[0] << *a.begin(); //三种方法一样，返回数组第一个元素 
	cout << a.back() << a[a.size() - 1]; //两种方法一样，返回数组最后一个元素 
	a.push_back(4); // 尾插，O（1）
	a.pop_back //删除最后一个元素,O(1) 
	return 0;
}

二、queue 

头文件queue主要包括循环队列queue和优先队列priority_queue两个数据结构

queue（队列）先进先出

#include<queue> //头文件 

using namespace std;

int main(){
	queue<int> a; //定义一个整型队列 
	queue<double> a; //定义一个浮点型队列 
	struct Rec{
		int a,b;
	};
	queue<Rec> a; //定义一个结构体队列
	a.push(1); //在队首插入一个元素 
	a.pop(); //弹出队尾元素 
	a.front(); //返回队首 
	a.back(); // 返回队尾 
	priority_queue<int> a; //定义一个大根堆：每次取最大值 
	priority_queue<int,vector<int>,greater<int>> a; //定义一个小根堆，每次取最小值 
	struct Rec{
		int a,b;
		bool operator< (const Rec& t) const{
		return a < t.a;
		}
	}; //定义结构体类型的大根堆优先队列需要重载小于号 
	priority_queue<Rec> a; //定义结构体类型的优先队列 
	priority_queue<pair<int,int>> a; //定义二元组优先队列 
	a.push(1); //插入一个数 
	a.top(); //弹出优先队列的顶部元素 
	a.pop(); //输出优先队列的顶部元素但不会删除它
    a.empty(); //检查优先队列是否为空
    a.size(); //返回优先队列中元素的数量
	return 0;
}

三、stack

stack（栈）先进后出

#include<iostream>
#include<stack> //头文件 

using namespace std;

int main(){
	stack<int> stk; //定义一个栈 
	stk.push(); //栈顶插入 
	stk.top(); //弹出栈顶元素 
	stk.pop(); //删除栈顶元素 
	return 0;
}

四、deque

deque（双端队列）是一个支持在两端高效插入和删除元素的线性空间，像是vector和queue的结合，与vector相比deque在头部增删元素只需O（1）的时间，与queue相比，deque可以像数组一样支持随机访问

#include<iostream>
#include<deque> //头文件 

using namespace std;

int main(){
	deque<int> a;
    a[1]; //随机访问
	a.begin(); //返回deque的头迭代器 
	a.end(); //返回deque的尾迭代器 
	a.front(); //从队首入队 
	a.back(); //从队尾入队 
	a.pop_front(1); //从队首出队 
	a.pop_back(1); //从队尾出队 
	a.clear(); //清空队列 
	return 0;
}

五、set

头文件set主要包括set（有序集合）和multiset（有序多重集合）两个容器，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树，他们支持的函数基本相同。

#include<iostream>
#include<set> //头文件 

using namespace std;

int main(){
	set<int> a; //元素不能重复
	multiset<int> b; //元素可以重复
	set<int>::iterator it = a.begin(); //定义迭代器 
	a.begin(); //返回第一个元素的迭代器，O(1) 
	a.end(); //返回a最后一个元素的后一个位置的迭代器,O(1) 
	a.insert(x); //插入x,O(logn)
	a.find(x); //查找x，返回迭代器，如果没有x，返回a.end(),O(logn)
	a.lower_bound(x); //二分找到大于等于x的最小的元素的迭代器,O(logn)
	a.upper_bound(x); //二分找到大于x的最小的元素的迭代器,O(logn)
	a.erase(x); //删除一个元素或者迭代器,O(logn)
	a.count(x); //集合中x的个数,O(logn)
	struct Rec{
		int a,b;
		bool operator< (const Rec& t) const{
		return x < t.x;  //重载小于号 
		}
	}; 
	set<Rec> c;
	return 0;
}

size/empty/clear 与vector类似、

set中的方法multiset都可以使用

六、map

map容器是一个键值对key—value的映射，其内部实现是以一棵以key为关键码的红黑树，map的key和value可以是任意类型，其中key必须定义小于号运算符

#include<iostream>
#include<vector>
#include<map> //头文件 

using namespace std;

int main(){
	map<string,vector<int>> a;
	a["lxy"] = vector<int>({1,2,3,4});
	cout << a["lxy"].size();
	
	return 0;
}

size/empty/clear/begin/end均与set类似

七、unordered_set、unordered_map

#include<iostream>
#include<vector>
#include<unordered_set> //头文件 
#include<unordered_map> //头文件 
using namespace std;

int main(){
	unordereded_set<int> a; //哈希表，不能存储重复元素 
	unordered_multiset<int> b; //哈希表，可以存储重复元素 
	
	unordered_map<int,int> c; //哈希表
    c.insert({x,y}); //插入键x值y
    c.find(x); //找到键x，存在返回键x对应值的迭代器，不存在则返回end()迭代器
    c.end(） //返回一个迭代器，指向哈希表的末尾位置
	return 0;
}