stl学习入门

STL_learning

STL即C++中的标准模板库，对程序的简化有非常好的效果，在竞赛中也能节省时间，
配合好的方法会有奇效		//think_weige  note!
 

转载请标明出处 


STL的使用，stl的使用需要包含相应的头文件，并使用标准命名空间
using namespace std;

#include<vector>		//使用该容器需要引入的头文件 
vector 类型 
//1.常规类型的定义
vector<typename> v; //直接用类型名字定义
//例如：
vector<int> v;//整型
vector<double> v;//浮点型
vector<Node> v;//结构体类型

//2.指定大小的定义
vector<int> v(n) //定义存放n个int类型的vector容器
vector<int> v(n,1);//基本类型定义时，初始化为n个1；

//3.二维数组的定义的三种方法
vector<vector<int> > v;//v是包含了多个vector容器的vector容器,注意> >之间的空格不能省略

vector<int> v[100];//定义100个存放int型数据的变长数组，其中v[0]~v[99]都是一个变长数组
					//改写法二维数组的长度已经固定为100，这是和第一种写法的区别
					
vector<vector<int> > v(m,vector<int> (n));
					//定义一个m*n的二维数组
					
//vector数组的遍历
//vector数组的遍历可以采用常规数组的遍历方法，直接使用下标，或者使用迭代其(类似于指针)的方法 
v[i]=0;
v.begin()+i;

//vector数组的常规操作，以int型数组为例
 vector<int> v;
 v.push_back(num); //将num插入到v的尾部，对结构体数组而言，push_back()可以插入结构体类型的变量
 v.pop_back();  //删除vector尾部的元素
 v.size();   	//返回数组v的大小
 v.clear();		//将v清空
 
 v.back();		//取容器尾部的元素
 v.resize(n);	//把容器大小修改为n
 v.reserve(n); 	//把容器的存储能力修改到n，但是size不变
  
vector<int>:: iterator it=v.begin()+3;	//定义一个数组v的迭代器指向第三个位置
v.insert(it,13);	//在迭代器it指向的位置插入元素13
v.erase(it);		//删除迭代器指向的元素
v.erase(first,last); 	//删除迭代器[first,last)左闭右开的区间内的元素

v1.assign(v2.begin(),v2.end());  //将v2数组赋值给v1，会清除v1以前的内容
v.insert(v.end(),v1.begin(),v1.end());		//将v1插入到v的后边



#include<stack>		//使用该容器需要引入的头文件
//栈的定义 
stack<typename> name;	//typename可以为任意数据类型，name即为你定义的栈的名字
//如： 
stack<int> st 
stack<char> st;
stack<string> st;
//stack的常用操作
st.push(x);	//将x压入栈中
st.pop();	//删除栈顶元素(注意删除没有放回值) 
st.top()	//获得栈顶元素 
st.empty();	//判断栈是否为空，为空则返回true
st.size();	//返回栈的大小


#include<queue> 		//使用该容器需要引入的头文件
//队列的定义
queue<typename> q;	//typename可以为任意数据类型，name即为你定义的栈的名字
q.front();	//获得队首元素
q.back();	//获得队尾元素
q.pop();	//出队
q.push(x);	//将x元素入队
q.empty();	//判断队列是否为空，为空则返回true 
q.size();	//返回队列 
//还有个优先队列,暂不做解释其类型为
priority_queue<typename> name; 





#include<set>		//使用该容器需要引入的头文件
set//基于红黑树搭建的容器 
//set即为集合，是一个内部自动有序且不含重复元素的特殊容器
set<typename> name;	//单独定义一个set
set<typename> Arrayname[arraysize]  //Arrayname[0]~Arrayname[arraysize-1]中的每一个都是一个容器,与vector类似
set<typename>::iterator it; //set只能通过迭代器访问
//typename是定义set时set的类型；如
set<int>::iterator it;
set<char>::iterator it;		//这样就得到了迭代器it，可以通过*it来访问其中的元素


/**************注：除了vector和string类型容器其余STL容器均不支持*(it+i)方式访问*************/
set的常用函数
set<int> st;	//定义st集合 
int i;cin>>i;	//定义i 
st.insert(i); 	//将i插入st中
st.find(i) //返回的是它的迭代器
若是需要输出的话即为
set<int>::iterator it=st.find(i);	//将返回迭代器传递给it 
cout<<*it;
st.erase(i);	//删除单个元素i;		时间复杂度为O(logN) 
st.erase(st.find(i));//删除它的迭代器	时间复杂度为O(1) 
st.erase(first,last);	//删除[first,last)区间内的元素
set<int>::iterator it=st.find(i);
st.erase(it,st.end());	//删除i到st末尾之间的元素 
st.size();	//获得set内元素的个数
st.clear();	//清空st内所有元素 
 
 

/***********STL中string***********/ 
#include<string> 		//使用该容器需要引入的头文件
//如果要读入和输出整个字符串，则只能用cin和cout
//****若要用printf输出整个字符串，可以将其转换为字符数组输出*****/
string str="weige";
printf("%s\n",str.c_str());
//与前面的一样也能通过迭代器来访问，string中每一位元素
//不需要设置参数
string::iterator it;
string str="weige";
for(string::iterator it=str.begin();it!=str.end();it++)
	cout<<"*it";//最后会输出weige 
//string可以之间将两个string拼接起来 
string str1="weige";
string str2="666";
str1=str1+str2;
cout<<str1;	//输出了weige666
//string也可以直接用==,!=,<=,>=,>,<等操作 
str.length();	//可以返回str的长度
str.size();		//也可以返回str的长度，与上述效果类似
insert(pos,string)	//在pos号位置插入字符串string
str="weige",str1="666";
str.insert(3,666);	//直接在3号位置，此位置与其存储位置一致 
cout<<str;	//输出了wei666ge 
insert(it,it2,it3)	//it为原字符串欲插入的位置,it2,和it3为待插字符的首尾迭代器表示[it2,it3]插入到it位置
//如： 
str="weige",str1="666";
str.insert(3,str2.begin(),str2.end());	//str变为了 wei666ge
str.erase();	//可以用于删除单个元素，也可用于删除一个区间所有元素 
string str3="wei666ge";
str3.erase(3,3);	//从pos=3开始删除3个元素,即剩下为weige
//用迭代器删除即为
str3.erase(str.begin()+3,str3.end());
str.clear();	//清空str
substr(pos,len);返回从pos号位开始、长度为len的字符串
string str="weige666";
cout<<str.substr(5,3);	//输出了666 
str.find(str2);	//当str2是str的字串时返回str第一次出现的位置
string str="weige666weige";
string str2="weige";
str.find(str2);	//返回值为0,即w的位置
str.replace(pos,len,str2);	//把str从pos号位开始，长度为len替换为str2
str.replace(5,3,str2);	//替换为了weigeweigeweige
str.replace(str.begin()+5,str.begin()+8,str2);	 //替换为了weigeweigeweige




#include<algorithm>			//以下函数需要引入的头文件
/*****************************************************************************/
max(a,b);                       //返回a和b中的最大值，参数可以是浮点数
min(a,b);                       //返回a和b中的最小值，参数可以是浮点数
tolower(char ch);               //将字符型变量ch的大写转换为小写，其他不变
toupper(char ch);               //将字符型变量ch的小写转换为大写，其他不变 
isdigit(char ch);               //判定一个字符是不是0~9的数字，参数是int型，这里为了好理解写成char
isalpha(char ch);               //判断一个字符是不是字母，参数是int型，这里为了好理解写成char 
islower(char ch);               //判断是不是小写，参数是int型，这里为了好理解写成char
isupper(char ch);               //判断是不是大写，参数是int型，这里为了好理解写成char
abs(x);                         //返回x的绝对值，参数x必须是整数
swap(a,b);                      //交换a，b的值，不会损失精度
reverse(it1,it2);               //对迭代器[it1,it2)范围内的所有元素进行反转
next_permutation(a,a+3);        //将int型数组a~a+3之间的元素，排成当前序列的下一个全排列
                                //例如a的前三个元素是2，3，1 则下一个序列是3，1，2
fill(a,a+n,value);              //将数组a的n个元素全部填充为值value
//说明，二维数组的写法可有以下两种，G[m][n]
fill(G[0],G[0]+m*n,value);      //涉及到二维指针的解引用，不能像一维数组那样直接写G
fill(G[0][0],G[0][0]+m*n,value);
fill(v.begin(),v.end(),value);  //对于容器，可以使用迭代器作为参数

//排序函数
sort(首地址，尾地址的下一个地址，比较函数);         //不填写比较函数时，默认升序排列
sort(a,a+n,cmp);                              //对a的n个元素进行排序
sort(v.begin(),v.end(),cmp);                  //对vector容器进行排序

//比较函数的实现
//基本类型的排序
bool cmp(int a,int b){
    return a<b;                 //按照从小到大，如果是大于号> 则从大到小排
}
//结构体的多级排序，假设结构体的定义如下
typedef struct node{
    string id;
    int high;
    int weigh;
}Node;
bool cmp(Noe a,Node b){
    if(a.id!=b.id)      return a.id<b.id;      //如果名字不同，按照名字的字典序从小到大排序
    else if(a.high!=b.high) return a.high<b.high;   //如果名字相同，但是高度不同，从低到高排序
    else     return a.weigh<b.weigh;            //如果名字和高度都相同，重量不同，按照重量从小到大排序
}

//排序的技巧
//如果结构体的数据量比较大，则采用下标排序的方式，减少时间复杂度
int index[100];                                 //记录原始的下标，初始化为index[i]=i
vector<Node> v(100);                            //存放结构体的容器，为了让比较函数能够访问，直接定义为全局变量
bool cmp(int a,int b){                          //对下标排序，比较函数的参数为下标的类型，即整型
    if(v[i].id!=b.id)      return v[i].id<b.id; //引用结构体数组确定排序规则
    ...                                         //以下写法类推
    ...
}

lower_bound(first,last,val);                    //在数组或者容器的[first,last） 范围内找到第一个大于等于val的位置，然会下标或者迭代器
upper_bound(first,last,val);                    //在数组或者容器的[first,last） 范围内找到第一个大于val的位置，然会下标或者迭代器
//如果找不到这样的位置，返回可以插入该元素的位置的下标或者指针