STL的模板

一、栈（stack）
1 . 头文件：<stack>
2 . 定义：stack<date_type>stack_name;
3 . 操作：
s.empty();//返回bool类型，表示栈内是否为空
s.size();//返回栈元素个数
s.top();//返回栈顶元素
s.pop();//移除栈顶元素
s.push(a);//向栈内压入一个元素a

二、队列（queue）

1 .头文件：<queue>
2 .定义：queue<date_type>queue_name;
3 .操作： q.empty();//返回bool类型，表示queue内是否为空 q.size();//返回queue内元素个数 q.front();//返回queue内下一个元素（返回第一个元素，即队头）
q.back();//返回queue内最后一个元素（队尾）
q.push(a);//将一个元素a置入queue中（只能从底端加入元素）
q.pop();//移除queue中的一个元素（只能从顶端移除，即从最小下标移除）

三、向量（vector)
1.头文件：<vector>
2.定义：vector<date_type>vector_name;
嵌套定义：vector<vector<int>> M;
3.操作：
ve.empty();//返回bool类型，表示vector内是否为空
ve.size();//返回vector内元素个数
ve.push_back(date_type a);//将元素a插入最尾端
ve.pop_back();//将最尾端元素删除（也可以从队友或队尾删除元素）
ve.front();//返回第一个位置
ve.back();//返回最后一个位置
ve.clear();//清空
veve.erase(pos);//可以清空一个位置的元素，也可以清空一个区间的元素，使用迭代器
ve.insert();
ve.insert(ve.begin(),10); //在起始位置插入10
ve.insert(ve.begin(), 2, 10); //在起始位置插2个10
ve.insert(ve.begin(), ve2.begin(), ve2.end());//在起始位置插入 某个区间（地址）
v[i]类似数组取第i个位置的元素
accumulate 区域求和; 三个参数，前两个是范围，最后一个是初始值eg: sum = accumulate(a.begin(), a.end(), 0);
swap() 交换两个vectorswap(ve1, ve2)
reverse(v.begin(),v,end());或者reverse(v,v+len());//为反转这个数组

四、集合（set）
1.头文件：<set>
2.定义：set<date_type>set_name;
3.操作：
s.intsert(elem);//安插一个elem副本，返回新元素的位置
s.erase(elem);//移除与elem元素相等的所有元素，返回被移除元素的个数
s.erase(pos);//移出迭代器pos所指位置上的元素，无返回值。 s.clear();//移除全部元素，将容器清空
s.find(x);//查找元素所在位置, 成功返回迭代器指向要查找的元素，失败返回的迭代器指向
ends.count(x);// 统计容器中等于x元素的个数
(multiset)s.size();//返回容器大小
s.empty();//返回容器是否为空
s.count(elem);//返回元素值为elem的元素的个数（只针对multiset）
s.lower_bound(elem);//返回 元素值>= elem的第一个元素位置
s.upper_bound(elem);//返回元素值 > elem的第一个元素的位置以上位置均为一个迭代器
s.begin();//返回一个双向迭代器，指向第一个元素
s.end();//返回一个双向迭代器，指向最后一个元素的下一 个位置
s.insert(x);//在集合中插入元素
s.rbegin();//返回指向集合中最后一个元素的反向迭代器
s.rend();//返回指向集合中第一个元素的反向迭代器s
.max_size();//返回集合能容纳的元素的最大限值

五、映射（map）
1.头文件：<map>
2.定义：map<date_type1,date_type2>map_name;
嵌套定义：eg:map<int,map<int,string> >multiMap;
3.操作：
m.size();//返回容器大小
m.empty();//返回容器是否为空
m.count(value);//返回实值等于value的元素的个数
m.find(value);//返回迭代器位置
m.lower_bound(key);//返回键值等于key的元素的第一个可安插 的位置
m.upper_bound(key);//返回键值等于key的元素的最后一个可安 插的位置
m.begin();//返回一个双向迭代器，指向第一个元素
m.end();//返回一个双向迭代器，指向最后一个元素的下一个 位置。
m.clear();//将整个容器清空
m.erase(elem);//移除键值为elem的所有元素
m.erase(pos);//移除迭代器pos所指位置上的元素直接元素存取
m[key] = value;//查找的时候如果没有键值为key的元素，则安插一个键值为key的新元素，实值为默认(一般0)
m.insert(elem);//插入一个元素elem
swap(map1，map2);//交换两个map

六、list
STL中的list容器底层数据结构用的是双向链表。这样数据在存储和删除的时候都可以做到时间复杂度是O(1)。
1.头文件：<list>
4. 定义：list<date_type>list_name;
5. 操作：
li.push_front(a);// 在它的头部添加一个元素a
li. push_back(a);//可以在 list 容器的末尾添加一个元素a
li.insert();//在 list 容器内部添加元素
li.insert(it,value)：在迭代器 it 位置插入一个值为 value 的元素并返回其迭代器，原 it 及以后的元素后
li.insert(it,num,value)：在迭代器 it 位置插入 num 个值为 value 的元素并返回其迭代器，原 it 及以后的元素后移
li.emplace();//在迭代器指定的位置构造一个元素
li.emplace_front();//在 list 的第一个元素之前构造元素
li.emplace_back();//在 list 的尾部元素之后构造元素
li.clear();//将整个容器清空
li.erase(elem);//移除键值为elem的所有元素，返回个数，对 于map来说非0即1（map中键值不能重复）
li.erase(it_begin,it_end)：删除迭代器 [it_begin,it_end] 区间的元素并返回最后一个被删除的元素的下一元素迭代器
li.unique() 非常有意思，它可以移除连续的重复元素，只留下其中的第一个
li.begin();// 返回的是指向第一个的双向迭代器
li.end();//返回最后一个元素下一个位置的双向迭代器

六、优先队列（priority_queue）
1.头文件： <queue>
6. 定义：priority_queue <data_type> priority_queue_name;
7. 操作：
q.push(elem);//将元素elem置入优先队列
q.top();//返回优先队列的下一个元素
q.pop();//移除一个元素（最大的一个元素）
q.size();//返回队列中元素的个数
q.empty();//返回优先队列是否为空
q.back();//.返回q的末尾元素
4.less和greater优先队列(less是从大到小，greater是从小到大):
声明格式：
priority_queue <int,vector<int>,less<int> > p;
priority_queue <int,vector<int>,greater<int> > q;

七、pair
1.头文件：<utility>
2.定义： pair<data_type1,data_type2> pair_name;
3.构造和访问：
pair<data_type1,data_type2> p：构造一个空 pair，其中无任何元素
pair<data_type1,data_type2> p(elem1,elem2)：构造一个元素值分别为 elem1、elem2 的 pair
pair<data_type1,data_type2> p1(p2)：产生另一个同型 pair 的副本，所有元素都被复制
pair 的一对值可以具有不同的数据类型（T1 和 T2），两个值可以分别通过其公有函数 first、second 来进行访问与赋值。
4.赋值：
1）利用 make_pair() 函数来赋值

pair<int, double> p1;
p1 = make_pair(1, 1.2);

2）变量间赋值

pair<int, double> p1(1, 1.2);
pair<int, double> p2 = p1;

七、全排列函数
格式：

do{
 .........;
 }while(next_permutation(a,a+n));

举个例子：

#include<bits/stdc++.h>
 using namespace std;
 int main()
 {    
 int a[5],t=0;    
 while(cin>>a[0]>>a[1]>>a[2]>>a[3])   
  {        
       int x,y;       
       if(a[0]==0&&a[1]==0&&a[2]==0&&a[3]==0)          
               break;       
       if(t!=0)         
           cout<<endl;;       
       t=1;y=1;       
       do       
       {           
              if(a[0]==0)               
                   continue;            
              if(y!=0)           
              {            
                      cout<<a[0]<<a[1]<<a[2]<<a[3];//控制第一个数                
                       y=0;          
               }           
              else if(x==a[0])                
                    cout<<" "<<a[0]<<a[1]<<a[2]<<a[3];//控制每行剩下的数           
              else          
              {               
                       cout<<endl;              
                       cout<<a[0]<<a[1]<<a[2]<<a[3];//控制换行           
              }           
             x=a[0];     
        }  while(next_permutation(a,a+4));        
       cout<<endl; 
       }   
      return 0;
}

八、重载运算符

1. 重载格式：
   返回值类型& operator 运算符（形参表）
   {}
   或者
   返回值类型 operator 运算符（形参表）
   {}
   2.几种形式：
   （1) 重载赋值运算符:
   eg:

X &operator = (const X &p)
 { 
 x_=p.x_; 
 y_=p.y_;
  return *this;//一个函数是引用类的话返回的实际上是一个地址 
  }

(2) 重载>运算符
eg:

class Student {   
     bool operator>(const Student& p)    
     {      
          if(score>p.score)          
             return true;        
          else if(score==p.score&&name<p.name)           
             return true;       
          else return false;   
      }
 };