C++标准模板库容器的常见用法

1.vector

1.1 定义

相当于是一维的变长数组

vector<typename> name;

1.2 元素访问

• 下标访问 vi[index]
• 迭代器访问 vector<typename>::iterator it;

1.3 常用函数

• push_back(x)在vector后面添加一个元素x，时间复杂度O(1)
• pop_back()删除vector尾元素，时间复杂度O(1)
• size()获得vector中元素的个数，时间复杂度O(1)
• clear()清空vector中所有元素，时间复杂度O(N)，N为元素个数
• insert(it,x)向vector的任意迭代器it处插入一个元素x，时间复杂度O(N)
• erase(it)删除迭代器为it处的元素，erase(first,last)删除一个区间[first,last)内的所有元素，时间复杂度均为O(N)

1.4 常见用途

1. 存储数据：在元素个数不确定的场合可以很好地节省空间
2. 用邻接表存储图

2.set

2.1 定义

集合，内部自动有序且不含重复元素的容器，内部使用红黑树实现，实现从小到大的排序功能

set<typename> name;

2.2 元素访问

只能通过迭代器访问，树状结构，有序

set<typename>::iterator it;

2.3 常用函数

• insert(x)将x插入set容器中，并自动递增排序和去重，时间复杂度O(logN)
• find(value)返回set中对应值为value的迭代器，时间复杂度为O(logN)
• erase(it)删除迭代器为it处的元素，时间复杂度为O(1)，erase(value)删除值为value的元素，时间复杂度为O(logN)。erase(first,last)删除一个区间[first,last)内的所有元素，时间复杂度均为O(last-first)。
• size()获得set内元素的个数，时间复杂度为O(1)
• clear()清空set中的所有元素，时间复杂度为O(N)

2.4 常见用途

自动去重并按升序排序

3.string

需添加#include<string>头文件

3.1 定义

string str;

3.2 元素访问

• 下标访问 string型变量使用c_str()变为字符数组可用%s输出
• 迭代器访问string::iterator it;

3.3 常用函数

• operator+=字符串拼接
• 比较运算符比较大小，比较规则是字典序
• size()/length()返回string的长度，时间复杂度为O(1)
• insert(pos,string)，在pos号位置插入字符串string。insert(it,it2,it3)，表示待插字符串[it2,it3)将被插在it的位置上。
• erase(it)删除单个元素。erase(first,last)删除一个区间内所有元素
• clear()清空string中的数据，时间复杂度一般为O(1)
• substr(pos,len)返回从pos号位开始，长度为len的子串，时间复杂度为O(len)
• string::npos，是一个常数，本身值为-1，但是是unsigned_int类型
• find(str)，当str是子串时，返回其在str中第一次出现的位置，如果不是，则返回string::npos。find(str2,pos)，从str的pos号位开始匹配str2，返回值与上相同。时间复杂度为O(nm)，n和m分别为两个字符串的长度。
• replace()，str.replace(pos,len,str2)，把str从pos号位开始、长度为len的子串替换为str2。str.replace(it1,it2,str2)，把str的迭代器[it1,it2)范围的子串替换为str2.

4.map

将任何基本类型映射到任何基本类型，内部使用红黑树实现，在建立映射的过程中会自动实现从小到大的排序功能。

unordered_map，以散列代替map内部的红黑树实现。

4.1 定义

map<typename1,typename2>mp;    //key是typename1，value是typename2

4.2 元素访问

• 下标访问，也就是键访问
• 迭代器访问map<typename1,typename2>::iterator it;使用it->first访问键，使用it->second访问值。

4.3 常用函数

• find(key)返回键为key的映射的迭代器，时间复杂度为O(logN)
• erase(it)，删除迭代器为it的元素，时间复杂度为O(1)。erase(key)，删除映射键为key的元素，时间复杂度为O(logN)。erase(first,last)删除一个区间的所有元素。
• size()获得map中映射的对数，时间复杂度为O(1)。
• clear()清空map中的所有元素，复杂度为O(N).

4.4 常见用途

1. 需要建立字符（或字符串）与整数之间的映射
2. 判断大整数或者其他类型数据是否存在
3. 字符串和字符串的映射

5.queue

先进先出的容器

5.1 定义

queue<typename> name;

5.2 元素访问

• 通过front()来访问队首元素
• 通过back()来访问队尾元素

5.3 常用函数

• push(x)将x入队，时间复杂度为O(1)
• front()、back()获得队首和队尾元素，时间复杂度为O(1)
• pop()令队首元素出队，时间复杂度为O(1)
• empty()检测queue是否为空，返回true则空，返回false则非空，时间复杂度为O(1)
• size()返回queue内元素的个数，时间复杂度为O(1)

5.4 常见用途

1. 广度优先搜索

6.priority_queue

6.1 定义

优先队列，底层是用堆来进行实现的，队首元素一定是当前队列中优先级最高的一个。

priority_queue<typename> name;

6.2 元素访问

• 只能通过top()来访问队首元素（堆顶元素），也就是优先级最高的元素

6.3 常用函数

• push(x)令x入队，时间复杂度为O(logN)
• top()获得队首元素（即堆顶元素），时间复杂度为O(1)
• pop()令队首元素（即堆顶元素）出队，时间复杂度为O(logN)
• empty()检测优先队列是否为空，返回true则空，返回false则非空，时间复杂度为O(1)
• size()返回优先队列内元素的个数，时间复杂度为O(1)

6.4 常见用途

解决一些贪心问题，也可以对Dijkstra算法进行优化

7.stack

后进先出的容器

7.1 定义

stack<typename> name

7.2 元素访问

通过top()访问栈顶元素

7.3 常用函数

• push(x)将x入栈，时间复杂度为O(1)
• top()获得栈顶元素，时间复杂度为O(1)
• pop()弹出栈顶元素，时间复杂度为O(1)
• empty()检测stack内是否为空，时间复杂度为O(1)
• size()返回stack内元素的个数，时间复杂度为O(1)

7.4 常见用途

模拟递归算法

8.pair

将两个元素绑在一起作为一个合成元素，可以看作一个内部有两个元素的结构体，且这两个元素的类型是可以指定的

struct pair{
    typeName1 first;
    typeName2 second;
};

8.1 定义

需要添加头文件#include<utility>

pair<typeName1,typeName2> name;    //初始化
pair<string,int> p("haha",5);      //定义时初始化

//在代码中临时构建一个pair
pair<string,int>("haha",5);    //方式一
make_pair("haha",5);           //方式二，使用自带的make_pair函数     

8.2 元素访问

pair中只有两个元素，分别是first和second，只需要按正常结构体的方式去访问即可。

#include<iostream>
#include<utility>
#include<string>
using namespace std;
int main(){
	pair<string,int> p;
	p.first="haha";
	p.second=5;
	cout<<p.first<<" "<<p.second<<endl;
	p=make_pair("xixi",55);
	cout<<p.first<<" "<<p.second<<endl;
	p=pair<string,int>("nene",555);
	cout<<p.first<<" "<<p.second<<endl;
	return 0;
} 

8.3 常用函数

• 使用比较运算符比较大小，比较规则是先以first大小作为标准，只有当first相等时才去判断second的大小

8.4 常见用途

1. 用来代替二元结构体及其构造函数，节省编码时间
2. 作为map的键值对来进行插入

map<string,int> mp;
mp.insert(make_pair("nene",5));
mp.insert(pair<string,int>("haha",9));
for(auto it=mp.begin();it!=mp.end();it++)
	cout<<it->first<<" "<<it->second<<endl;

9.algorithm头文件下常用函数

1. max(x,y)、min(x,y)返回x和y中的最大值和最小值，如果要返回三个数的最大值，可使用max(x,max(y,z))
2. abs(x)返回整数x的绝对值，浮点型的绝对值用math头文件下的fabs
3. swap(x,y)交换x和y的值
4. reverse(it,it2)将数组指针在[it,it2)之间的元素或容器的迭代器在[it,it2)范围内的元素进行反转
5. next_permutation()给出一个序列在全排列中的下一个序列
6. fill(起始位置，终止位置的下一个位置，值)把数组或容器的某一段区间赋为某个相同的值，和memset不同，这里的赋值可以是任意值
7. lower_bound()和upper_bound()需要用在一个有序数组或容器中；lower_bound(first,last,val)用来寻找[first,last)范围内第一个大于等于val元素的位置，如果是数组则返回指针，如果是容器则返回迭代器；upper_bound(first,last,val)用来寻找第一个值大于val的元素的位置。
8. sort(首元素地址，尾元素的下一个地址，比较函数)，默认按递增排序，整型浮点型char型数组都可

#include<stdio.h>
#include<algorithm>
#include<vector>
using namespace std;

struct node{
	int x,y;
	node(){}
	node(int _x,int _y){
		x=_x;
		y=_y;
	}
}ssd[10];

bool cmp(node a,node b){
	if(a.x!=b.x) return a.x>b.x;
	else return a.y>b.y;
}

bool cmp2(int a,int b){
	return a>b;
}

int main(){
	//结构体排序 
	ssd[0]=node(2,2);
	ssd[1]=node(1,3);
	ssd[2]=node(2,1);
	sort(ssd,ssd+3,cmp);
	for(int i=0;i<3;i++){
		printf("%d %d\n",ssd[i].x,ssd[i].y);
	}
	
	//容器的排序，只有vector、string、deque是可以使用sort的
	//因为set、map这种容器底层是用红黑树实现的，元素本身有序，不允许使用sort排序
	vector<int> vi{1,9,1,0};
	vi.push_back(3);
	vi.push_back(8);
	vi.push_back(6);
	sort(vi.begin(),vi.end(),cmp2);
	for(int i=0;i<vi.size();i++)
		printf("%d ",vi[i]); 
	return 0;
}