vector

vector，译为：向量。这里指变长数组。

定义
	vector<typename> name;//定义一个name变长一维数组
	vector<vector<int> > name;//定义一个变长二维数组name，int型
	vector<typename> name[Maxn];//定义一个二维数组name，外维是定长的，内维度是变长的
访问
	//访问方法一：迭代器访问
	vector<typename>::iterator it;//it类似于指针，访问元素时：*it
	//访问方法二：数组常规访问
	vector<int> a;
	a[0];//对应数组的第一个元素
常用函数
	#include<vector>
	vector<int> vi；//初次定义时候，数组为空，长度为0
	vector<int>::iterator it;//定义一个vector的指针it，这是一个迭代器，名为it
	vi.push_back(x);//将x添加到变长数组的尾部
	it=vi.begin();//it指向数组的第一个元素的地址；vi[i]等价于*(vi.begin()+i);
	it=vi.end();//it指向数组元素最后一个元素的下一个地址，也就是数组结束的地址，类似于串的‘\0’元素的地址
	//注意：关于迭代器的比较，对应：it!=vi.end();只能这样比较。不存在it<vi.end();
	vi.pop_back();//删除vi的尾元素
	int size=vi.size();//size为容器的大小，也就是数组的长度
	vi.clear();//清空容器vi
	vi.insert(it,x);//在迭代器it处插入x，其他元素整体后移；
	vi.erase(it);//删除迭代器it所指的元素
	vi.erase(fiest,end);//删除迭代器从first到end范围的元素，[first,end)

set

set，译为：集合，是一个内部自动有序且不含重复元素的容器。

定义
	set<typename> name;//定义一个名为name的typename类型的集合，它可以实现自动去重
访问

！！！set的访问只能通过迭代器(iterator)访问。

	set<int>::iterator it;
	只有vector和string支持*(it+i)的访问方式
常用函数
	#include<set>
	set<int> st;
	set<int>::iterator it;
	st.insert(x);//将x插入set容器中，并自动递增去重
	it=st.find(x);//返回集合中x的位置。返回的是一个迭代器
	st.erase(it);//删除位置为it的元素
	st.erase(value);//删除set中值为value的元素
	st.erase(first,end);//删除迭代器所指区间为[first，end)位置的元素
	int num=st.size()；//获取set中元素的个数
	st.clear();//清空set

string

string，就是对字符串及其功能的封装。

定义
	string str；
	string str=“hello world！”；
访问

！！！注意：读入、输出整个字符串只能用cin，cout；

	cout << str[i];/通过下标访问
	string::iterator it;
	cin >> str;//遇到空格或者回车结束输入
	cout << *it;//通过迭代器访问
	getline(cin,str);//从输入流读取一行字符到str，遇到回车结束('\0'),忽略空格；
常用函数

1、运算符重载

	string str1="Hello ";
	string str2="world!";
	string str3=str1+str2;
	cout << str3 << endl;

2、比较操作，直接比较，字典顺序

	string str1="Hello";
	string str2="world";
	if(str1<str2) 		cout << "str2 is bigger!" << endl;

3、经常使用的“小函数”

	int length = str.length();
	int length = str.size();
	string::iterator it;
	it = str.begin();//it指向串的首元素
	it = str.end();//it指向串的结束位置
	str.insert(3,str2);//在str的str[3]位置处插入串str2，其他元素全部往后平移
	str.insert(it,it2,it3);//将迭代器it2和it3之间的元素，加入到迭代器it所指的位置
	str.erase(it);//删除迭代器it所指的元素
	str.erase(str.begin()+2,str.end());//删除自串 str[2]之后的所有元素，[str.begin+2 , str.end)
	str.erase(3,2)；//删除从3号元素开始的2个字符
	str.clear();//清空串
	str2 = str.substr(3,2);//将str的第3号元素开始的2个字符，传给str2
	//string::npos 意思是“没有位置了，也就是到了串的末尾了”，其本身为-1或者4294967295（2的32次方-1，对应二进制也就是32个1）
	//string::npos 用以作为find函数失配时的返回值，代表查找失败，没有这样的元字串
	int pos = str.find(str2);//返回字串str2在str出现的第一个位置
	int pos2 = str.find(str2,7);//从str的7号位开始匹配str2，返回第一次匹配成功的位置
	str.replace(0,5,str2)；//从0号位开始，长度为5的字串，被str2替换
	str.replace(it1,it2,str2);//从迭代器所指区间[it1，it2) 之间的元素，被str2替换
map

map，译为映射。map可以将任何基本类型映射到任何基本类型。
map会以键从小到大的顺序自动排序。

定义
#include<map>
using namespace std;
//映射前的叫键（key），映射后的叫值。map中键必须使唯一的。
map<typename1,typename2> mp;
map<string,int> mp;
//如果使字符串到int的映射只能用string，不可以使用char[]
map<set<int>, string> mp;
访问
//下标访问
map<char,int> mp;
mp['c']=20;
cout << mp['c'] << endl;
//迭代器访问
map<typename1,typename2>::iterator it;
mp['m']=20;
mp['r']=30;
mp['a']=40;
for(map<char,int>::iterator it=mp.begin(); it!=mp.end(); it++)
{
   
	cout << it->first << it->second << endl;
}
//it->first访问键，it->second访问值
//注意map会以键从小到大的顺序自动排序j
常用函数
it=mp.find(key);//返回键为key的迭代器
mp.erase(it);//删除迭代器所指的单个元素
mp.erase(key);//删除键为key的单个元素
mp.erase(it,mp.end());//删除[it，mp.end)区间内的元素
int num=mp.size();
mp.clear();//清空map
queue

队列。常用于广度优先搜索树**。使用front()和pop()函数前，必须使用empty()判断队列是否为空。**

定义
queue<int> q;
常用函数
q.push(x);//将x入队，置于队尾
q.pop();//令队首元素出队
cout << q.front() << q.back();//发别输出队首和队尾的元素
if(q.empty());
priority_queue

优先队列。队首元素一定是当前队列中优先级最高的一个。常用于贪心算法。无front()和back()函数，只能通过top()函数来访问队首元素。

定义
priority_queue<int> q;
元素访问
cout << q.top();
常用函数
q.push(x);//将x入队
q.pop();//令队首元素出队
if(q.empty());
int sum=q.size();
队列优先级设置
priority<int ,vector<int> , less<int> > q;//数字大优先级大
priority<int ,vector<int> , greater<int> > q;//数字小优先级大

//结构体优先级设置
struct fruit{
   
	string name;
	int price;
	friend bool operator < (fruit f1, fruit f2){
   
		return f1.price<f2.price;
	}
};
//friend 友元；bool operator < (fruit f1, fruit f2) 是一个重载
//优先队列设置的排序，与sort设置的排序，效果相反。
stack

栈。常用于模拟实现一些递归，防止程序对栈内存的限制而导致程序运行出错。

定义
stack<int> st;
元素访问

只能通过top()来访问栈顶元素。

cout << st.top();
常用函数
st.push(x);//将x入栈
st.pop();
if(st.empty());
int num=st.size();
pair

将两个元素绑在一起作为一个合成元素。用来代替二元结构及其构造函数，可以节省编码时间。也可作为map的键和值作为插入。

定义
#include<utility>
//如果忘记了头文件的名字
#include<map>//添加map时候，会自动添加utility
pair<string, int> p;
元素访问

只能用first和second。

pair<string, int> p;
p.first = "haha";
p.second = 5;
cout << p.first << " " << p.second << endl;
p = make_pair("xixi" , 55);//自带的函数用于初始化
p = pair<string, int>("heihei", 555);
可以直接比较

比较规则是： 先以first的大小为标准，first相同时，比较second大小。

作为map的键和值插入
#include<iostream>
#include<string>
#include<map>
using namespace std;
int main()
{
   
	map<string , int> mp;
	mp.insert(make_pair("haha",5));
	mp.insert(make_pair("heihei",10));
	for(map<string , int>::iterator it = mp.begin(); it!= mp.end(); it++)
	{
   
		cout << it->first << " " << it->second << endl;
	}
	return 0;
}
algorithm头文件下的常用函数

只有vector、string、deque可以使用sort ；set、map自动排序。 // deque双端队列

int max_ = max(a,b);
int min_ = min(a,b);
int x = abs(x);
float x = fabs(x);
swap(a,b);//a，b在内存中互换位置
reverse(it,it2);//反转迭代器 或者 指针 所指区间[it,it2)之间的元素的顺序
sort(it , it2 ,cmp)//按照cmp的排序规则，对指针或 迭代器 所指区间[it,it2)之间的元素排序

lower_bound(first, last, val) 用来寻找在数组或容器的[first，last)范围内第一个值>=val的元素的位置；若是数组，则返回该位置的指针；若是容器，则返回该位置的迭代器。
upper_bound(first，last，val) 用来寻找在数组或容器的[first，last)范围内第一个值>val的元素的位置；若是数组，则返回该位置的指针；若是容器，则返回该位置的迭代器。

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
   
	int a[10]={
   1,2,2,3,3,3,5,5,5,5};
	printf("%d,%d\n", lower_bound(a,a+10,3)-a,upper_bound(a,a+10,3)-a);
	return 0;
}
//结果： 3，6