STL

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

#include<vector>  头文件

vector<int>a （{1，2，3}）    相当于一个长度动态变化的int数组

vevtor<int>b[223]   相当于第一维长223，第二位长度动态变化的int数组

struct rec{....}

vector<rec>c        自定义的结构体类型也可以保存在vector中

1.size/empty

  size函数返回vector的实际长度（包含元素的个数），empty函数返回一个bool类型，表明vector是否为空。二者的时间复杂度都是O（1）。

所有的STL容器都支持这两个方法，含义也相同。

2.clear

  clear函数把vector清空。

3.迭代器

  迭代器就像STL容器的指针，可以用“*”操作符解除引用。

  一个保存int的vector的迭代器的声明方法：

  vector<int>::iterator it

  vector的迭代器是随机访问迭代器，可以把vector的迭代器与一个相加减，其行为和指针的移动类似。可以把vector的两个迭代器相减，其结果也和指针相减类似，得到两和迭代器下标的距离。

4.begin/end

  begin函数返回指向vector中第一个元素的迭代器，例如a是一个非空的vector，*a.begin{}与a[0]的作用相同。

    所有的容器都可以视作一个前闭后开的结构，end函数返回vector的尾部，即第n个元素再往后的边界。*a.end{}与a[n]都是越界访问，其中n=a.size()

 

下面两份代码都遍历了vector<int>a,并输出它的所有元素。

for(int i=0;i<a.size();i++) cout<<a[i]<<endl;

for(vector<int>::itreator it=a.begin{}；it!=a.end{};it++) cout<<*it<<endl;

 

5.front/back;

front函数返回vector的第一个元素，等价于*a.begin{}和a[0]

back函数返回vector的最后一个元素,等价于*==a.end()和a[a.size()-1]

6.push_back()和pop_back()

  a.push_back(x) 把元素x插入到vector a的尾部

  a.pop_back()  删除vector a的最后一个元素

 

二.#include<queue>
  头文件queue主要包括循环队列queue和优先队列priority_queue两个容器。

声明：

  queue<int>q;

  struct rec{...}:queue<rec>q;  //结构体rec中必须定义小于号         (编译器无法比较结构体类型数据（自定义数据类型）的大小，但是优先队列是要把最大的那个挑出来的，这个最大的怎么挑出来，需要我们自已定义规则，也就是重写大于号的规则,大根堆重载小于号，也是同理)

  struct Rec{
  int a,b;

  bool operator< (const Rec& t) const

{

return a<t.a;

};//重载小于号

  priority_queue<int>q;   //大根堆  (优先返回大的数）

  priority_queue<int,vector<int>,greater<int>q ; //小根堆（返回最小值）

  priority_queue<pair<int,int>q;

循环队列 queue

 q.push(1)　　 从队尾插入

 q.pop 从队头弹出

 q.front()  返回队头

 q.back()  返回队尾

 q.top()   取最大值

 q.pop()  删除最大的

 

三.#include<stack>
  头文件stack包括栈，声明和前面的容器类似。

  push向栈顶插入

  pop弹出栈顶元素

四.双端队列

  #include<deque>

  双端队列deque是一个支持在两端高效插入删除元素的连续性存储空间。它就像是vector和queue的结合。与vector相比，deque在头部增删元素仅需O（1）的时间；与queue相比，deque就像数组一样支持随机访问。

begin/end  返回deque的头/尾迭代器

front/back  队头/队尾元素

push_back 从队尾入队

push_front 从队头入头

pop_back  从队尾出队

pop_front  从队头出队

clear  清空队列

a[0]  随机数

 

五.#include<set>

头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即其拿着的元素不能重复，而后者可以包括若干的相等的元素，set和multiset的内部实现是一颗红黑树，它们支持的函数基本相同。

set<int>a;

struct Rec{

int x,y;

bool opreator< (const Rec& t) const

{

return x<t.x;

}

};

结构体rec中必须定义小于号

size/empty/clear与vector类似

 

迭代器

set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持星号解除引用，仅支持“++”和“--”两个与算术相关的操作

设it是一个迭代器，例如set<int>::iterator it;

若把it++,则it会指向下一个元素，这里的下一个元素是指在元素从小到大排列的结果中，排在it下一名的元素，同理，若把it--，则it会指向排在上一个的元素

begin/end 

返回集合的首、尾迭代器，时间复杂度均为O（1).

s.begin()是指向集合中最小元素的迭代器

s.end()是指向集合中最大元素的下一个位置的迭代器。换言之，就像vector一样，是一个“前闭后开”的形式。

 

insert

s.insert(x)把一个元素x插入到集合s中，时间复杂度为O（logn)。

在set中，若元素已存在，则不hi重复插入该元素，对集合的状态无影响。

 

find

s.find(x)集合中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。时间复杂度为O(logn)

 

lower_bound和upper_bound

s.lower_bound(x)查找大于等于x的元素中最小的元素，并返回指向该元素的迭代器。

s.upper_bound(x)查找小于x的元素中最小的元素，并返回指向该元素的迭代器。

 

erase

设it是一个迭代器，s.erase(it)从s中删除迭代器it指向元素，时间复杂度为O（logn)

设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为O(k+logn)，其中k是被删除的元素个数

 

count

s.count(x)返回集合s中等于x的元素个数，时间复杂度为O（k+logn)，其中k为元素x的个数。

 

六.#include<map>

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

声明：

map<key_type,value_type>

例如：

map<long,long,bool>vis

map<string,int>hash

map<pair<int,int>,vector<int>test

 

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

 

pair

pair<int,string>a;

a={3,"wjt"}

cout<<a.first<<" "<<a.second<<endl;