STL总结

STL总结

总结一下常用STL用法
本文只提供一些常用方法，具体实现请读者自行尝试

测评大致数据范围：

准确数值浮动，主要参考数量级。

vector

可变数组

#include<vector>

vector<int> vec;
vector<int> vec;        //声明一个int型向量
vector<int> vec(10);    //声明一个初始大小为10的int向量
vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量
vector<int> tmp(vec.begin(), vec.begin() + 3);  //用向量vec的第0个到第2个值初始化tmp
int array[5] = {1, 2, 3, 4, 5};   
vector<int> vec(array, array + 5);      //将arr数组的元素用于初始化vec向量
//末尾指针都是指结束元素的下一个元素和vec.end()指针统一
vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值

//大小操作
vec.empty()    //判断是否为空
vec.size()     //输出实际大小
vec.max_size()  //输出最大容量
vec.resize()    //重新定义大小,保留适当的容量

//插入元素
vec.push_back();     //末尾添加元素
vec.insert(vec.begin()+i,a);        //任意位置插入元素 在第i+1个元素前面插入a

//删除元素
vec.pop_back();    	 //末尾删除元素 
vec.clear();	     //清空向量元素
vec.erase (vec.begin()+5);                 // erase the 6th element
vec.erase (vec.begin(),vec.begin()+3); // erase the first 3 elements:
 
  

//迭代器
vec.begin();		//起始指针：
vec.end(); 			//指向最后一个元素的下一个位置
vec.cbegin(); 		//不能通过这个指针来修改所指的内容，但可以通过其他方式修改的。
vec.cend();			//指向常量的末尾指针
vec.rbegin()		//反向迭代器头
vec.rend()			//反向迭代器尾
vec.crbegin()
vec.crend()

//元素访问
vec[1]; 			//下标访问，并不会检查是否越界
vec.at(1); 			//at会检查是否越界，会抛出out of range异常
vec.front();        //访问第一个元素 
vec.back();         //访问最后一个元素

vec.swap(vec2); 		 //交换两个向量的元素
swap(vec,vec2);

stack

栈 （后进先出）

#include<stack>

stack<int> sta;
//大小操作
sta.empty()
sta.size()

sta.push(x)  //将x加入到栈顶
sta.pop()	 //将栈顶元素弹出
sta.top()	 //返回栈顶元素

//C11
sta.swap(sta1) //交换栈sta和sta1中的元素
sta.emplace(x) //将x放入到栈顶

//栈的清空
while(!sta.empty()) sta.pop();

queue

队列 （先进先出）

#include<queue>

queue<int> que;
que.size()   //返回队列中元素的个数
que.empty()  //如果为空，返回true

que.front()  //返回第一个元素（即队首元素）
que.back()   //返回队尾元素

que.pop()    //删除第一个元素
que.push(x)  //在队尾加入一个元素

que.swap(que1) 	//交换que和que1的元素
que.emplace(x)  //向队首加入元素

//queue不提供清空操作，一般手动实现
while(!que.empty()) que.pop();

queue入队，如例：q.push(x); 将x 接到队列的末端。
queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问queue队首元素，如例：q.front()，即最早被压入队列的元素。
访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。
判断queue队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

priority_queue

优先队列 (STL中的堆)

#include<queue>
/*
*  模板原型：
*  priority_queue<Type,Container,Functional>
*/
priority_queue<int> que;     //默认是降序的
priority_queue<int,vector<int>,greater<int>> que1;  //升序队列
priority_queue<int,vector<int>,less<int>> que2;     //降序队列

//对于结构体的比较
class student {
	public:
		string name;
		int score;
		student(string na, int sc):name(na), score(sc) {}
};
struct cmp {
	bool operator() (const student& a, const student& b ) {
		return a.score > b.score;
	}
};
priority_queue<student, vector<student> , cmp> que;   //根据成绩从大到小排序

//具体操作
que.empty();
que.size();

que.push(x);		//加入元素到队尾
que.pop();			//从队首删除元素

que.top();     		//返回队首元素

que.emplace(x)
que.swap(que1)

map

#include<map>
/*
*  map<key,value>
*/
map<int,int> ma;
ma.size();
ma.empty();
int x =ma[2];  // 返回value
//若没有赋值，直接返回0
cout<<ma[1]<<endl;

list

实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。

//其中的list或者a、b都是list类型的变量

//构造函数
list<int> first;                                // empty list of ints
list<int> second (4,100);                       // four ints with value 100
list<int> third (second.begin(),second.end());  // iterating through second
list<int> fourth (third);                       // a copy of third

//插入元素
a.insert(a.begin(),100);  //在a的开始位置（即头部）插入100
a.insert(a.begin(),2, 100);   //在a的开始位置插入2个100
a.insert(a.begin(),b.begin(), b.end());//在a的开始位置插入b从开始到结束的所有位置的元素
list.push_back(x)  //在链表尾插入元素
list.push_front(x) //在链表头插入元素

//迭代器
list.begin()    //获得指向链表尾的指针
list.end()      //获得指向链表尾（尾的下一个元素）的指针
list.rbegin()	//获得反向链表的头指针
list.rend()		//获得反向链表的尾（尾的下一个元素）指针
//以下为 C11 标准，返回的是常量指针，不能通过指针进行值的修改。
list.cbegin()
list.cend()
list.crbegin()
list.crend()

//大小判断
list.empty()      //判断是否为空，为空，返回true
list.size()		  //返回list的实际大小
list.max_size()   //返回list的最大容量

//获得元素
list.front()      //获得头元素
list.back()       //获得尾元素

//删除操作
a.erase(a.begin()); 		 //将a的第一个元素删除
a.erase(a.begin(),a.end());  //将a的从begin()到end()之间的元素删除。
//必须保证不为空
list.pop_back()   //删除尾元素
list.pop_front()  //删除头元素
list<int> a {6,7,8,9,7,10}; a.remove(7);   //删除指定元素


//其他操作
list.assign(n,value)  //list将被改为n个值为value的元素
list.resize(x)   //将链表改为长为x   超出的部分将被删除
swap(a,b)   //交换a,b链表的值
list.reverse()   //将链表倒置
a.merge(b)   //将链表b添加到链表a的后面

//补充以下迭代器的使用
//以下是四种迭代器的遍历操作（如果使用C11标准，可以直接使用auto）
    list<int>::iterator cur1=li.begin();
    for(;cur1!=li.end();cur1++){
        cout<<*cur1<<" ";
    }
    cout<<endl;
    
    list<int>::const_iterator cur2=li.cbegin();
    for(;cur2!=li.cend();cur2++){
        cout<<*cur2<<" ";
    }
    cout<<endl;
    
    list<int>::reverse_iterator cur3=li.rbegin();
    for(;cur3!=li.rend();cur3++){
        cout<<*cur3<<" ";
    }
    cout<<endl;
    
    list<int>::const_reverse_iterator cur4=li.rbegin();
    for(;cur4!=li.rend();cur4++){
        cout<<*cur4<<" ";
    }

//C11标准
    auto cur=li.begin();
    for(;cur!=li.end();cur++){
        cout<<*cur<<" ";
    }

set

#include<set>
set<int> se;
se.empty()
se.size()
se.max_size()

se.clear()
se.insert()
se.erase()
se.swap()

se.find()