C++常用STL(standard template library)

常用STL(standard template library)

动态数组 vector

声明 ：

//记得在使用vector时要先引入头文件
#include<vector>
//建议初始化在全局变量的位置
vector<int> vec1;//一维
//二维，最好在里面的那个<>里面加一个空格
vector<vector<int> > vec2;
//定义二维动态数组并赋初始值
vector<vector<int> > vec(n,vector<int>(m,0))

struct Student{
    string name;
    int age;
};

vector<Student> class1;//vector 也可以定义一个结构体数组

重要：二维动态数组的正确赋值方法：不会空指针

vector<vector<int> > v2d;
for(int i = 0;i < 5;i++){
    //要想可以直接使用v2d[i].push_back需要先开空间
    v2d.push_back(vector<int>());//因为v2d [] 不具有开空间，插入的功能
}
for(int i = 0;i < v2d.size();i++){
    for(int j = 0;j <= i;j++){
        v2d[i].push_back((i + 1) * (j + 1));
    }
}

数组和动态数组结合使用：

#include<iostream>
#include<vector>
using namespace std;
int main(){
	//vector 可以和数组结合使用
	vector<int> numd2[101];//表示 开101个动态二维数组
	for(int i = 0;i < 5;i++){
		numd2[i].push_back(i);
		numd2[i].push_back(i * i);
	} 
	for(int i = 0;i < 5;i++){
		cout << numd2[i][0] << " " << numd2[i][1] << endl;
	}
	return 0;
} 

插入：

vec1.insert()//有三种函数重载，但是都需要传入迭代器，不建议使用
vec1.push_back(i)//可以直接将值插入到动态数组的最后面

删除：

vec1.pop_back();//删除最后一个元素
vec1.erase(iterator loc);//有两种函数重载，都要传入迭代器
vec1.clear();//清除所有元素，size为0 ,但是空间仍然存在于内存之中

集合set

#include<set> //使用set前引入头文件
set<int> s;  //声明
s.insert(2);//插入一个值为2的数  log(n)
s.insert(2);//由于2已经存在，所以不会进行任何操作
s.erase(2);//将2从集合中删除 log(n)
s.erase(2);//集合中已经没有2了，所以不会进行任何操作
s.count(2);//在集合中查找值为2的元素的个数，返回值为0或1
s.insert(2);//插入一个值为2的数
s.insert(3);
int size = s.size(); //ln(1)
//对set的遍历要使用迭代器
for(set<int>::iterator it = s.begin();it != s.end();it++){
    cout << (*it) << " " ;
}//注意：set是已经是从小到大排好序的，所以如果要用结构体，要重载小于号
s.clear();//既会清除所有元素，又会清除内存  ln(n)，最好后面加上

//最后有一种常用的初始化set的方法
set<int> s(array.begin(),array.end());

结构体集合：使用时一定要先重载小于号，只要重载小于号

struct Node{
    int x,y;
    bool operator<(const Node &rhs) const{//小于号重载
        if(x == rhs.x){
            return y < rhs.y;
        }
        else{
            return x < rhs.x;
        }
    }
}
//遍历结构体
set<Node> v;
for(set<Node>::iterator it = v.begin();it != v.end();it++){
    cout << it->x << " " ;//用->访问
}

映射表 map

定义一个名为m的从T1类型到T2类型的映射。

map<T1 t1,T2 t2> m;

//插入一个新的映射  参数为pair
/*
pair 为一个标准库类型，定义在头文件utility 中，可以看成是有两个成员变量的结构体（first,second)，并且重载了< 运算符（先比较first),
*/
#include<utility>
#include<map>
using namespace std;
int main(){
	map<string,int> m;
	pair<string,int> p;//声明一对映射关系
	p = make_pair("weifeng",1);//构建一个pair
	m.insert(p);
    p = make_pair("weifeng",1);
    //不能插入，（key,value）由于key=weifeng已经存在，将不会插入
    p = make_pair("xuxu",1);//value=1 已经存在可以了插入
    //也可以通过[] 来进行赋值
    m["1"];//可以将key="1"的pair插入，其中value为默认值
    //int 为 0 ，double 为 0.0 ,string 为 "",
    m["1"] = 1;//既可以插入，又可以更改
    m.count("1");//可以检测是否存在key = "1"的一组映射
	cout << m["weifeng"] << endl;
    
   	//遍历，我认为有两种常见的方法
    //方法1:在已知key数组的情况下
    for(int i = 0;i < array.size();i++){
        //也可以用范围for但有的编译器不支持
        cout << m[array[i]] << " ";
    }
    //方法2：
    for(map<string,int>::iterator it = m.begin();it != m.end();it++){
        cout << it->first << "  " << it->second << "  ";
        //first 为 关键字key， second 为对应值 value
        //map 也是按照关键字从小到大遍历，即它本身就是从小到大有序的
        //所以如果是结构体映射，任然要重载小于号
        /*
        struct Node{
        	int x,y;
        	bool operator < (const Node & rhs) const{
        		if(x == rhs.x){
        			return y < rhs.y;
        		}
        		else{
        			return x < rhs.x;
        		}
        	}
        }
        */
    }
    m.clear();
	return 0;
} 

map 的应用：

1. 我们经常把string 映射成 int : 这样方便操作

   map<string,int> dict;

2. map 套用

栈 Stack s

Stack<int> s;
s.push(4);//增加栈顶元素
s.size();
s.top();//获得栈顶元素
s.pop();//移除栈顶元素
s.empty();

队列 Queue q

queue<int> q;
q.push(4);//在队尾添加一个元素
int n = q.size();
int l = q.back();//返回队尾元素
int f = q.front();//返回第一个元素
q.pop();//移除队首元素
bool b = q.empty();
//运用while循环删除整个队列
while(!q.empty()){
    q.pop();
}