C++标准模版库STL

vector(长度根据需要自动改变的数组)

1.vector的定义

vector<typename>name;
举例：
vector<int>str1; //
vector<int>str2[100]; //第一维可变的二维数组
vector<vector<int> >str3; //两维都可变的二维数组，注意空格

2.vector容器内元素的访问

（1）通过下标访问

str1[index] //index的范围是0到str1.size()-1.

（2）通过迭代器访问

vector<int> vi;
迭代器类似于指针，定义方式：
vector<int>::iterator it = vi.begin();//取vi的首地址，it指向这个首地址
cout << *(it + 3) //输出vi[3], vi[i]和*(vi.begin()+i)是等价的
for(it = vi.begin(); it != vi.end(); it++){//循环条件只能为it!=vi.end();
	cout << *it;
}
只有	vector,string才能使用vi.begin()+3 这种迭代器加数字的写法

3.vector常用函数

vi.push_back(n); //在vector vi后面添加一个元素n,时间复杂度O(1)
vi.pop_back(); //删除vector vi的尾元素， O（1）
vi.size(); //获得vi中元素的个数，O(1),返回的为unsigned类型
vi.clear(); //清空vi里的元素，O(N),N为vi中的元素个数
vi.insert(it, x); //向vector的任意迭代器it处插入一个元素x,O(N)
vi.erase(it); //删除it处的一个元素，O(N)
vi.erase(first, last); //删除[first, last)区间的所有元素，可以使用迭代器

set()(内部自动有序且不含重复元素的容器)

set的定义

#include<set>
using namespace std;
set<typename> name;

举例：

set<int> numbers;
set<node> nodes; //结构体类型
set<int> a[100]; //a[0]到a[a.size() - 1]中的每一个都是一个set容器

set容器内的访问

只能通过迭代器的方式访问，而且不支持*(it + i)的方式访问

set<int> ss;
set<int>::iterator it;
int a = *it; //利用*it 访问set里的元素
//枚举操作如下
for(it = ss.begin(); it != ss.end(); it++){
	cout << *it;
}

set容器常用函数

ss.insert(x); //将x插入到ss中，自动递增排序和去重， O(log N)
ss.find(value); //返回值为value的迭代器，O(log N)
ss.erase(it); //删除it迭代器位置的元素， O(1)
ss.erase(ss.find(100)); //配合find函数使用
ss.erase(value); //删除value值的元素
ss.erase(first, last); //删除[first, last)区间内的所有元素,first和last均为迭代器地址，O(last - first)
ss.size(); //获取元素个数
ss.clear(); //清空ss

string(对字符串常用需求封装的类型)

1.string的定义

#include<string>
using namespace std;
string str;
string str = “abide”;

2.string中的内容的访问

string类型，如果要读入和输出整个字符串，只能用cin 和cout。
(1)通过下标访问，类似于字符数组的方式访问string。
(2)通过迭代器访问

string::iterator it;
for(it = str.begin(); it != str.end(); it++){
	cout << *it;
}
同vector一样支持如下方式
cout << *(it + 3);
cout << *(str.begin() + 3);

3.string常用函数

(1)运算符号“+=”

string str1 = “abc”, str2 = “xyz”, str3;
str3 = str1 + str2; //将str1和str2拼接赋值给str3;
str1 += str2;
输出结果：
str3 = abcxyz
str1 = abcxyz

(2)可以使用”==, !=, <, >, <=, >= “比较打下，规则为按照字典序
(3)求字符串长度函数，length() 或者 size();

string str = “abcxyz”;
cout << str.length() << str.size(); //两者基本相同
输出结果：
6 6

(4)insert()函数
insert(pos, string); 在pos位置插入字符串string

string str = “abcxyz”;
string str2 = “ops”;
str.insert(3, str2); //输出结果：str = abcopqxyz;
str.insert(3, ops); //结果同上

str.insert(it, it2, it3); it为原字符串str欲插入位置， it2 ，it3为待插入字符串的首尾迭代器，表示串[it2, it3)将被插在it位置上。

str.insert(str.begin() + 3, str2.begin(), str2.end()); //结果同上

(5)erase()删除函数
删除单个元素：

str.erase(it); //需要删除元素的迭代器
string str = “abcxyz”;
str.erase(str.begin() + 3); //删除’x‘字符

删除区间内所有元素：

str.erase(first, last);//两个迭代器的[first, last)区间内的所有元素
str.erase(pos, length); //pos为要删除的起始位置 length为删除的字符个数

(6)clear() 清空string中的数据
(7)substr()

str.substr(pos, len); //返回从pos号位开始，长度为len的字串，O(len)
string str = “Thank you”;
cout << str.substr(0, 5); //输出：Thank
cout << str.substr(6, 3); //输出：you

(8)string::npos, 可以看作是-1 或者 4294967395.用作find函数查找失败的返回值。
(9)find()
O(nm) n和m为两个字符串的长度

str.find(str2); //当str2为str子串时，返回其在str中第一次出现的位置；如果不是str的子串，返回string::npos.
str.find(str2, pos); //从pos位查找st2,返回值同上

(10)relace()替换函数
O(str.length)

str.replace(pos, len, str2); //把str从pos 号位开始，长度为len的子串替换为str2.
str.replace(it1, it2, str2); //把str迭代器[it1, it2)范围的子串替换为str2.

map()

1.map的定义

map 可以将任何基本类型映射到任何基本类型，如mp
将字符串映射到整数，只能使用string不能使用char数组，如mp2
将set容器映射整数，如mp3
将int 映射int型，就相当于int型数组，如mp4.

#include<map>
map<typename1, typename2> mp;
map<string, int> mp2;
map<set<int>, string> mp3;
map<int, int> mp4;

2.map容器的访问

(1)通过下标方式访问

map<char, int> mp;
mp[‘c’] = 20;
mp[‘c’] = 30;
cout << mp[‘c’]; //30;

(2)通过迭代器访问
it->first 可以访问键，it->second可以访问值。

map<typename1, typename2>::iterator it;
map<char, int> mp;
mp[‘m’] = 20;
mp[‘r’] = 30;
mp[‘a’] = 40;
map<char, int>::iterator it = mp.begin();
for(; it != map.end(); it++){
	cout << it->first << “ “ << it->second << endl;
}
//输出如下
a 40
m 20
r 30

由结果可知map在建立映射的过程中，会以键从小到大顺序自动排序。

3.map常用函数

mp.find(key);//返回键为key的映射的迭代器，O(log N)
mp.size(); //获得map中映射的对数，O(1)
mp.clear(); //清空，O(N)
mp.erase(it); //删除迭代器所指向的一对映射，O(1)
mp.erase(key); //删除键所在的一对映射， O(log N)
map.erase(first, last); //使用迭代器删除[first, last)区间的映射，O(last - first)

queue()队列和stack()栈

队列和栈使用基本相同，下面举例队列
1.定义

#include<queue>
using namespace std;
queue<int> q;

2.访问

q.front();访问队首元素
q.back();访问队尾元素

3.常用函数
全为 O(1)时间复杂度

q.push(value); //value入队
q.pop(); //队首元素出队
q.empty(); //检测队是否为空，为空返回true
q.size(); //获取队里元素个数

priority_queue()

1.定义

#include<queue>
using namespace std;
prioty_queue<typename> q;

2.元素访问

q.top(); //访问队首元素

3.常用函数

q.push(value); //入队，O(log N)
q.pop(); //出队， O(log N)
q.empty(); 
q.size();

4.优先级设置
（1）基本类型
int,double一般是数字越大优先级越高，char为字典序最大优先级越高。优先级最高的在队首。以下两种等价

priority_queue<int> q; //默认数字越大优先级越高
priority_queue<int, vector<int>, less<int> > q; 

less< int >表示数字越大优先级越高
greater< int>表示数字越小优先级越高
如果想让最小的在最前的队首，定义如下

priority_queue<int, vector<int>, greater<int> > q;

(2)结构体

algorithm()

max(),min(),abs()

max(x, y),min(x, y)返回x和y的最大值和最小值
abs(x)返回整数x的绝对值
浮点型的使用math头文件下的fabs

swap()

swap(x, y)交换x和y的值

reverse()

将数组指针在[it, it2)之间的元素或容器的迭代器[it, it2)范围内的元素进行反转

reverse(it, it2);

next_permutation()

给出一个序列在全排列的下一个序列
int a[10] = {1, 2, 3};
do{
	cout << a[0] << a[1] << a[2] << “ ”;
}while(next_permutation(a, a + 3));
输出结果：
123 132 213 231 312 321

fill()

将数组或者容器中的某一区间赋为某个相同的值，
和memset不同，这里的赋值可以是数组类型对应范围中的任意值
int a[5] = {1, 2, 3, 4, 5};
fill(a, a + 5, 233);

sort()

lower_bound(),upper_bound()

使用在有序数组中或者容器中，如果没有需要寻找的元素，会返回可以插入该元素的位置的指针或者迭代器（假设该元素存在，该元素应当在的位置）

low_bound(first, last, val);
//寻找数组或容器的[first, last)范围内第一个值大于等于val的元素的位置，数组返回指针，容器返回迭代器
upper_bound(first, last, val);
//寻找数组或容器的[first, last)范围内第一个值大于val的元素的位置