c++的stl总结

1. #include<vector>

vector是一个长度动态变化的函数

vector<int>a 是一个长度动态变化的int类型数组

vector<int>b[233] 相当于一个第一维长度233，第二维长度动态变化的int数组

也可以创建一个结构体REC，然后用vector<REC>c 结构体长度动态变化

a.size（）可以求出a数组的长度

b.empty( ) 判断b数组是不是空的，如果是返回TRUE，不是空的返回FALSE。

a.clear( ) 删除a数组里的所有元素。

迭代器：相当于指针 引用： vector<int>::iterator p ;要用指针所指的数，用*号引用，如输出p所指的数：*p

a.begin( ) 指的是数组a的起始位置的地址

a.end( ) 指的是数组a的最后一位元素的下一位的地址

初始化a：vector<int>a({1,2,3});

遍历a：for(i=0;i<a.size();i++)

Vector<int>::iterator it;

for(it=a.begin();it!=a.end();it++)cout<<*it;

a.front( ) 指的是a的第一个元素

a.back( ) 指的是a的最后一个元素

auto 的作用是让编译器自己判断类型

a.push_back( 4) 是往a数组的最后边加一个元素4

a.pop_back( ) 是删除a数组的最后一个元素

2.#include<queue>

包括循环队列queue和优先队列priority_queue两个容器

queue是先进先出，priority_queue是先出最大的数

在头文件#include<queue>里

定义：queue<int>q; <>里可以更改类型如double或者结构体名称//队列

priority_queue<int> q; 默认的是大根堆//先出的是大的数

priority_queue<int,vector<int>,greater<int> > b;是小根堆//先出的是小的数

对队列

queue：q.push(1) 在队尾插入1；

q.pop( ) 弹出队头元素//删除队头元素

只能从队头插入，从队尾弹出

q.front( )返回队头元素

q.back( ) 返回队尾元素

对优先队列priority_queue:

1. push(1) 插入一个元素（不按顺序）

优先队列其实就是自己排序把大的排在前面

a.top( )取最大值//队头元素

a.pop( )删除最大值//删除队头

遍历队列：

当a不空时，输出队头然后删除队头

While（!a.empty( )）{

Printf(“%d ”,a.front( ));

a.pop( );

}

3.#include<stack>

栈，先进后出 （吃薯片，最开始装入的最后吃，一端开口的数据结构）

定义：stack<int> a;

a.push(1) 插入一个元素

a.top( )返回栈顶元素//最后一个插入的元素叫栈顶元素

a.pop( ) 删除栈顶元素

4.#include<deque>

双端队列，可以在队头队尾插入删除

定义：deque<int> a;

a.begin( ) a的首个元素地址

a.end( )a的最后一个元素的下一位的地址

a.back( )a的最后一个元素

a.front( )a的第一个元素

a.push_back(1)往a最后面插入一个1

a.push_front(2)在a的最前面插入一个2

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

a.pop_front( )删除第一个元素

a.clear（）清除一个队列

#include<set>

定义：set<int> a;//不包含重复元素,而且按从小到大排序

multiset<int> a;//可以包含重复元素

函数： a.size( )返回长度

a.empty( )是否为空

a.clear( )清除队列

a.end( )返回最后一个元素的后一个位置

a.insert(1 )表示插入一个元素1

a.find( 2)表示查找一个元素2，返回的是元素2的迭代器（指针），如果数组中没有这个元素则返回a.end( )

If(a.find(x)==a.end())判断x在a中是否存在

1. lower_bound( x)找到大于等于x的最小迭代器

1. upper_bound(x)找到大于x的最小元素的迭代器

s.erase(it)把it这个迭代器指向的元素删掉

s.erase(x)把容器中所有等于x的数都删掉

a.count (x) 表示x在a里的个数（因为set不存重复元素，所以存在x就返回1，不存在就返回0，multiset则返回个数）

#include<map>

定义：映射数组//前面的映射出后面的，就是输出后面的

如果存数组那么按字典序递增的方式储存

map<int,int> a;

a[1]=2;

a[1000000]=3;

Printf(“%d”,a[10000000])---输出3

<>里面的两个类型可以自己定义，比如字符串和数字：

map<string,int> a;

a[“zxh”]=2;

Printf(“%d”,a[“zxh”])--输出2

也可以定义字符串和vector数组：

map<string,vector<int> > a;

a[“zxh”]=({2,5,4,3});

Printf(“%d”,a[“zxh”][2])--输出5（vector的第二个元素）

函数：a.size( )

1. empty( );

1. clear( );

1. begin( );

1. end( );

1. insert()插入一个二元组：a.insert({“a”,{5}})

输入字符串然后来记录他出现的次数的话用

Map<string,int> a;

String x;

Cin<<x;

A[x]++;

遍历map：使用迭代器map<string,string> ::iterator it;

map<string,int> a;

map<string,int>::iterator it;

int n;

scanf("%d",&n);

for(int i=0;i<n;i++){

string s;

cin>>s;

a[s]++;

}

for(it=a.begin();it!=a.end();it++){

cout<<it->first<<' '<<it->second<<endl;

}

1. #include<algorithm>

reserve函数：用来逆序数组或vector数组。reserve(a.begin(),a+a.size())或reserve(a,a+n),n是数组a的元素个数.（参数是数组的首地址和最后地址的下一位）

unique函数：用来去除数组里的重复元素。必须要在去重之前排序，因为他删除的是相邻重复的元素unique(a,a+n)或unique(a.begin(),a.end())（要求是重复元素必须挨在一起）。有返回值，是去重之后数组最后元素的下一位地址。所以返回值减去a的首地址得到数组不同元素的个数。（参数是数组的首地址和最后地址的下一位）

random_shuffle函数：用来打乱数组中元素的顺序。random_shuffle（a.begin(),a.end()）（参数是数组的首地址和最后地址的下一位）

sort函数：用来排序数组（从小到大）。sort(a.begin(),a.end())或sort(a,a+n).（参数是数组的首地址和最后地址的下一位）.如果想从大到小排序用sort(a.begin(),a.end(),greater<int>()).

Sort的参数是数组的首位地址，末尾元素的下一位地址，和对应法则

Sort(a,a+n,cmp)

当对结构体里的东西排序时用cmp来写准则

#include<iostream>

#include<algorithm>

using namespace std;

struct name{

string st;

int s;

};

bool cmp(name a,name b){

return a.s >b.s ;

}

int main(){

int n;

scanf("%d",&n);

struct name a[400];

for(int i=0;i<n;i++){

cin>>a[i].st >>a[i].s ;

}

sort(a,a+n,cmp);

for(int i=0;i<n;i++){

cout<<a[i].st <<' '<<a[i].s <<endl;

}

return 0;

}

对字符串排序（按字典序输出最大）：

bool cmp(string a,string b){

for(int i=0;a[i]&&b[i];i++){

if(a[i]>b[i])return 1;

if(a[i]<b[i])return 0;

}

string s1=a+b;

string s2=b+a;

return s1>s2;

}

string s[100];

int n;

scanf("%d",&n);

for(int i=0;i<n;i++){

cin>>s[i];

}

sort(s,s+n,cmp);

for(int i=0;i<n;i++)cout<<s[i];

全排列函数：

在用之前要先排序

next_permutation实现升序；prev_permutation实现降序

拿升序举例：（降序就把next换成prev就可）

对整数数组：int a[4]={1,2,3,4};

Sort(a,a+4);

do{

for(int i=0;i<4;i++)printf(“%d  ”,a[i]);

Printf(“\n”);

}while(next_permutation(a,a+4));

对字符串全排列：string st;

cin>>st;

sort(st.begin(),st.end());

do{

cout<<st<<endl;

}while(next_permutation(st.begin(),st.end()));

算出集合{1,2，...m}的第n个排列：

比如算出{1,2,3,4,5,6,7}的第n=1654个排列：

int a[7]={1,2,3,4,5,6,7};

sort(a,a+7);

int n=1;

do{

if(n==1654){

for(int i=0;i<7;i++)printf("%d",a[i]);

printf("\n");

break;

}

n++;

}while(next_permutation(a,a+7));

lower_bound函数：返回大于等于x的最小迭代器（指针）

在头文件<algorithm>里；

用法：lower_bound(a.begin( ),a.end( ),x)//查找x

如果返回end（），就是没有，要是想查vector数组的下标，

Lower_bound(a.begin( ),a.end( ),x)-a.begin( )就是数组的下标

upper_bound函数：返回大于x的最小迭代器（指针）用法同上