「学习笔记」STL用法

STL集合

1 栈(stack)

1.1 成员函数

#include <stack>   		   //头文件
stack<elemtype> s;          //调用
unsigned int size()         //返回栈的元素个数
elemtype top()              //返回栈顶元素
void pop()                  //将栈顶元素弹出
void push(x)                //向栈中添加元素x
bool empty()                //判断栈是否为空 

1.2 单调栈应用

//1. 最基础的应用就是给定一组数，针对每个数，寻找它和它右边第一个比它大的数之间有多少个数。
//2. 给定一序列，寻找某一子序列，使得子序列中的最小值乘以子序列的长度最大。
//3. 给定一序列，寻找某一子序列，使得子序列中的最小值乘以子序列所有元素和最大。
/**
 * 本伪代码对应的是单调递减栈 
 * 共n个元素，编号为0~n-1
 */
while(栈为空) 栈顶元素出栈; //先清空栈
a[n]=-1;//保证栈内元素全部出栈
for(i=0;i<=n;i++)
{
	if(栈为空或入栈元素大于等于栈顶元素) 入栈;
	else 
	{
		while(栈非空并且栈顶元素大于等于入栈元素)
		{
			栈顶元素出栈;
			更新结果; 
		} 
		将最后一次出栈的栈顶元素（即当前元素可以拓展到的位置）入栈; 
		更新最后一次出栈的栈顶元素其对应的值; 
	} 	 
}

2 队列(queue)

2.1 普通队列

#include <queue>            //头文件
queue<elemtype> q;          //调用
unsigned int size()         //返回队列的元素个数
elemtype front()            //返回队头元素
elemtype back()             //返回队尾元素
void pop()                  //将队头元素出队
void push(x)                //向队尾添加元素x
bool empty()                //判断队列是否为空 

2.2 双端队列

/**
 * 成员函数
 */
#include <deque>             //头文件
deque<elemtype> dq;          //调用
unsigned int size()          //返回队列的元素个数
elemtype front()             //返回队头元素
elemtype back()              //返回队尾元素
void pop_front()             //将队头元素出队
void pop_back()              //将队尾元素出队
void push_front(x)           //向队头添加元素x
void push_back(x)            //向队尾添加元素x
bool empty()                 //判断队列是否为空 
void clear()                 //清空队列       O(n)
elemtype x=dq[0]             //像vector一样通过下标访问内容
/**
 * 双端队列的应用
 */
//维护固定合法区间段的最大值或最小值
deque<int> dq; //一般元素是下标
dq.clear();    //先清空队列
//单调递增队列，维护固定区间的最小值，队头为区间最小值对应的下标
//假设原数组:a[0~n-1]，固定区间为k
for(int i=0;i<n;i++)
{
	while(!dq.empty()&&a[dq.back()]>a[i]){//不满足递增性质的情况
        q.pop_back();
    }
    q.push_back(i);
    while(!q.empty()&&(q.front()<i-k+1)){//队头非法的情况
        q.pop_front();
    }
    //此处更新区间结果
    if(i>=k)ans[tot++]=a[q.front()];
}
/**
 * 优先级队列
 */
#include <queue> //头文件
priority_queue<elemtype> pq; //默认大顶堆
priority_queue<elemtype,vector<elemtype>,greater<elemtype> > pq; //小顶堆
//自定义类型需要自己定义优先级比较函数
struct node {     
　　int x,y;     
　　bool operator < (const node& a, const node& b) const 
　　{         
　　　　return a.x > b.x;  //结构体中，x小的优先级高     
　　}
};
unsigned int size()       //返回队列的元素个数
elemtype top()            //返回队头元素   
void pop()                //将队头元素出队    O(logn)
void push(x)              //向队内添加元素x   O(logn)
bool empty()              //判断队列是否为空

3 迭代器和pair

/**
 * 迭代器
 */
//可用于vector、list、set、map的遍历
vector<elemtype>::iterator it;
it begin()       //返回指向开头的迭代器
it end()         //返回指向末尾的迭代器
//1. vector、string、deque的迭代器是有加减法的；
//2. 而map、set、multimap、multiset、list的迭代器是没有加减法的。他们仅支持++it、–-it这些操作。
/**
 * pair
 */
//1. 使用pair<string, int> P来初始化或直接用make_pair(x,y)来建立一个结构体元素
//2. 第一个元素可以使用first访问，第二个元素可以使用second访问。eg: P.first和P.second

4 动态数组(vector)

#include <vector>           //头文件
vector<elemtype> v;         //调用初始化为空
vector<elemtype> v(v1);     //用另一个vector:v1来初始化，即构造一个副本
vector<elemtype> v(n,i);    //大小为n，并全部初始化为元素i(常用)
vector<elemtype> v(n);      //构造大小为n的容器，没有初始化里面的内容
vector<elemtype> v{x,y,z,k};//构造大小为4.并初始化里面的各个元素
//成员函数
unsigned int size()         //返回数组元素个数
elemtype back()             //返回末尾元素值
void push_back(x)           //向末尾添加元素x
void pop_back()             //删除末尾元素
bool empty()                //判空
void clear()                //清空数组
void insert(it,x)           //向位置it处插入元素x   O(n)
void erase(it)              //删除位置it的元素      O(n)
void resize(m)              //调整大小为m           O(n)
//函数功能类
#include <algorithm>        //头文件
swap(v[i],v[j]);            //交换元素  
sort(v.begin(),v.end());    //排序       O(nlogn)
reverse(v.begin(),v.end()); //反转	    O(n)

5 双向链表(list)

#include <list>             //头文件
list<elemtype> L;           //调用
//成员函数
unsigned int size()         //返回表的元素个数
bool empty()                //判空
void push_front(x)          //表头添加元素x
void push_back(x)           //表尾添加元素x
void pop_front()            //删除表头元素
void pop_back()             //删除表尾元素
void clear()                //清空数组             O(n)
void insert(it,x)           //向位置it处插入元素x   O(1)
void erase(it)              //删除位置it的元素      O(1)

6 集合(set)

6.1 set和multiset

//1. set是元素值进行排序的集合，所插入的元素在集合中唯一，不存在重复元素，而multiset可以存在重复元素。如果是结构体需要重载"<",来排序元素。
//2. set和multiset是由二叉搜索树实现，而且对树进行了平衡处理，使得元素在树中分布较为均匀，因此能保持搜素、插入、删除操作的复杂度在O(logn)。
#include <set>                //头文件
(multi)set<elemtype> s;       //调用
//成员函数
unsigned int size()           //返回集合元素个数
void clear()                  //删除集合内所有元素
void insert(x)                //在集合中插入元素x        O(logn)
unsigned int count(x)         //返回x值的个数            O(logn)
void erase(x)                 //删除含x的元素            O(logn)
it find(x)                    //搜索x元素，并返回指向该元素的迭代器，没有则返回end() O(logn)
//函数功能类
it s.lower_bound(x)      //返回指向元素值>=x的第一个元素位置的迭代器    O(logn)
it s.upper_bound(x)      //返回指向元素值>x的第一个元素位置的迭代器     O(logn)
pair<set<elemtype>::iterator,set<elemtype>::iterator> bounds;
bounds=s.equal_range(x)  //返回元素值=x的迭代器的区间                  O(logn)

6.2 unordered_set和unordered_multiset

//1. unordered_set是元素值不进行排序的集合，底层实现是hash原理,且与unordered_multiset的唯一区别是后者可存放重复元素。
//元素不能是自定义类型，只能是单一类型，如:int,char,string,bool
#include <unordered_set>                //头文件
unordered_(multi)set<elemtype> s;       //调用
//成员函数与set类似
unsigned int size()           //返回集合元素个数
void clear()                  //删除集合内所有元素       O(n)
void insert(x)                //在集合中插入元素x        O(1)~O(n)
unsigned int count(x)         //返回x值的个数            O(1)~O(n)
void erase(x)                 //删除含x的元素            O(1)~O(n)
it find(x)                    //搜索x元素，并返回指向该元素的迭代器，没有则返回end() O(1)~O(n)

7 键值对集合(map)

7.1 map和multimap

//1. map集合以键与值组合为元素，集合以值作为排序标准，和multimap的唯一区别是后者元素的"键"可重复。
//2. 可以使用"[ ]"来访问指定键对应的值或迭代器来访问每一对键和值。
//3. map和set一样通过平衡二叉搜索树来实现，因此元素的插入、删除、搜索以及"[ ]"运算的复杂度均为O(logn)
//4. map中的key默认是以less<>升序对元素排序（排序准则也可以修改），也就是说key必须具备operator < 对元素排序，而平常我们的用的基本上都是基本类型元素作为key，所以就不存在这个问题了。如果是结构体需要重载"<",来排序key值。
#include <map>                     //头文件
(multi)map<elemtype> m;            //调用
//成员函数
unsigned int size()                //返回集合元素个数
void clear()                       //删除集合内所有元素                   O(n)
void insert(make_pair(key,val))    //在集合中插入元素pair(key,val)        O(logn)
unsigned int count(key)            //返回被查找元素key的个数              O(logn)
void erase(key)                    //删除含键key的元素                    O(logn)
it find(x)                         //搜索与key一致的元素，并返回指向其的迭代器，没有则返回end() O(logn)
elemtype m[x]                      //可以通过下标直接访问key为x对应的val的值 O(logn)

7.2 unordered_map和unordered_multimap

//1. unordered_map是不对val进行排序的集合，底层实现是hash原理,且与unordered_multimap的唯一区别是后者可存放重复key的元素。
//2. 元素不能是自定义类型，只能是单一类型，如:int,char,string,bool
#include <unordered_map>                   //头文件
unordered_(multi)map<elemtype> m;          //调用
//成员函数与set类似
unsigned int size()                        //返回集合元素个数
void clear()                               //删除集合内所有元素                O(n)
void insert(make_pair(key,val))            //在集合中插入元素pair(key,val)     O(1)~O(n)
unsigned int count(key)                    //返回被查找元素key的个数           O(1)~O(n)
void erase(key)                            //删除含键key的元素                 O(1)~O(n)
it find(key)                    //搜索与key一致的元素，并返回指向其的迭代器，没有则返回end()  O(1)~O(n)
elemtype m[x]                   //可以通过下标直接访问key为x对应的val的值        O(1)~O(n)