c++常用STL小结

c++常用STL小结

容器container

栈stack

标准栈，后进先出（不支持遍历）。

• 头文件#include <stack>
• 命名空间std

使用方法：

int a；//元素
stack<int> st;//创建实例 <类型>
cin >> a;
st.push(a);//入栈
a = st.top();//栈顶
st.pop();//出栈
bool b = st.empty（）;//判断栈是否为空
int len = st.size();//返回栈长度

队列queue

标准队列，先进先出（不支持遍历）。

• 头文件#include <queue>
• 命名空间std

使用方法：

int a;//元素
queue<int> q;//创建实例 <类型>
cin >> a;
q.push(a);//进队
a = q.front();//返回队头
a = q.back();//返回队尾
q.pop();//出队
bool b = q.empty();//队列是否为空
int len = q.size();//返回队列长度

链表list

线性的双向链表（支持遍历），支持快速的插入和删除，不支持随机访问。

• 头文件#include <list>
• 命名空间std

使用方法：

///创建
int a[] = { 1,2,3,4,5 };//数组元素
list<int> lt;//创建实例
list<int>::iterator it;//创建迭代器
list<int> lt(a, a + 5);//用数组初始化 (首地址，尾地址)
list<int> lt(8, 10);//用数字初始化 (数量，值) 即8个10

///操作
//插入push_back,push_front
int a;//元素
cin >> a;
lt.push_back(a);//尾插入
lt.push_front(a);//头插入

//删除pop_back,pop_front
lt.pop_back();//删除尾
lt.pop_front();//删除头

//重置assign
list<int> first;
list<int> second;
first.assgin(8,10);//用数值连续重置
second.assgin(first.begin(),first.end())//迭代器指向序列重置

//指定插入insert
iterator insert (iterator position, const value_type& val);  //（插入位置的迭代器，插入的值）
void insert (iterator position, size_type n, const value_type& val); //（插入起始位置，数量，值）插入n个值为val的元素到position

template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);  //（被插入位置，插入起始，插入结束）把first到last全部插入到position

//遍历
list<int> lt;
list<int>::iterator it;
for (it = lt.begin(); it != lt.end(); it++) cout << *it <<endl;

///其他成员函数
//删除erase，同时销毁迭代器
lt.erase(iterator it);//删除it位置的元素
lt.erase(iterator begin,iterator end);//删除区间内的元素

//交换swap
list<int> first;
list<int> second;
first.swap(second);//交换两个list

//清空clear
lt.clear();

//转移元素splice
void splice (iterator position, list& x); //将列表x中的所有元素移到当前list中，从当前列表的position指向的位置开始，此时列表x为空
void splice (iterator position, list& x, iterator i);  //将列表x中迭代器 i 指向的元素移到当前list的position指向的位置处，由于i指向的元素从列表x中被移，所以迭代器 i 此时是invalid的；position是当前列表的迭代器，i是列表x的迭代器
void splice (iterator position, list& x, iterator first, iterator last);  //将列表x中[first, last)的元素移到当前list中，从position指向的位置开始；first,last是列表x的迭代器

//移除指定元素remove
void remove (const value_type& val);  //从list中删除所有值为val的元素

//删除重复值unique
void unique();  //删除相邻的重复元素，然后保留第一个值，因此这个函数只对排好序的list有用

//排序sort 默认升序，可自写cmp函数
lt.sort(cmp);

//逆序reverse
lt.reserve();

//合并有序列表merge
list<int> first;
list<int> second;
first.merge(second);

//按条件移除元素remove_if 
bool single_digit (const int& value) { return (value < 10); }
lt.remove_if (single_digit);

优先队列priority_queue

他和queue不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面，优先出队，默认大根堆

• 头文件#include <queue>
• 命名空间std

使用方法：

struct node//自定义优先级
{
	int x,y;
	bool operator < (const node & a) const
	{
		return x<a.x;
	}
};


int a;
priority_queue <int> que;//创建实例，默认降序
priority_queue <int, vector<int>, less<int> > que;//降序
priority_queue <int, vector<int>, greater<int> > que2;//升序
//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

priority_queue <node>;//重载小于，可以利用重载小于来自定义优先级

cin >> a;
que.push(a);//进队
a = que.top();//返回队头
que.pop();//出队
bool b = que.empty();//队列是否为空
int len = que.size();//返回队列长度

集合set

自动排序，元素值唯一的容器，底层由红黑树实现。

• 头文件#include <set>
• 命名空间std

使用方法：

///创建
set <int> se;
set <int>::iterator it;

//常用方法
//插入insert
int a;
set <int> se;
cin >> a;
se.insert(a);

//删除erase
se.erase(iterator it);

//查找find
se.find(2);//返回2所在的迭代器，否则返回end()

//lower_bound(查找第一个大于等于key的值)upper_bound(查找第一个大于key的值)
se.lower_bound(2);
se.upper.bound(2);

//是否出现某个值count(返回某一键值出现次数,set中使用此函数只会返回1或0)
int a = se.count(2);

///特殊用法
//可重复插入的集合mutiset
mutiset <int> se;

向量vector

可以理解为一个动态数组。vector作为容器，可以使用较多algorithm中的函数，例如sort，reverse，swap。

• 头文件#include <vector>
• 命名空间std

使用方法：

///创建
int b[7]={1,2,3,4,5,9,8};

vector <int> vec;
vector <int> vec(10,1);//用连续值初始化，10个1
vector<int> a(b,b+7);//用数组区间
vector <int>::iterator it;

///常用操作
//尾部插入一个元素push_back()
vec.push_back(a);

//插入一个元素insert()
vec.insert(position,elem) //在pos位置插入一个elem拷贝，传回新数据位置。
vec.insert(position,n,elem)	//在pos位置插入n个elem数据，无返回值。
vec.insert(position,begin,end)	//在pos位置插入在[beg,end)区间的数据，无返回值。

//删除指定位置的元素erase()
vec.erase(iterator it);

//[]访问，由于vector重载了[]，所以可以利用[]直接访问已有元素
cout << vec[1];//相当于数组操作

//返回指定位置的元素at()
vec.at(1);//at()函数具有检测是否越界的功能，如果越界会抛出错误，所以安全性高于[]

//迭代器遍历
vector <int> vec;
vector <int>::iterator it;
for (it = vec.begin(); it != vec.end(); it++) cout << *it;

//vec.clear();//清空

//vec.back(),vec.front(),vec.empty()//返回末尾，返回头，判断是否为空

//vec.begin(),vec.end()//传回对应位置的迭代器

关联map，pair

map内部也是通过红黑树实现的，map的形式为一个键值对，和set一样查找的复杂度为（logn）可以修改value值，但不能修改key值。

• 头文件#include <map>
• 命名空间std

使用方法：

///创建
map <int,string> mp;//创建了一个以int为key，string为value的键值对。
map <int,string>::iterator it; 

///常用操作
//插入insert() 注意前两种只能在map内无此元素的时候插入，而最后一种可以实现覆盖再赋值
mp.insert(make_pair(1, "one"));//利用make_pair函数构造出一对关联量插入
mp.insert(map<int, string>::value_type(1, "one"));//插入map的value_type数据
mp[1] = "one";//利用重载[]输入赋值

//删除earse()
mp.erase（iterator it);//通过一个条目对象删除
mp.erase（iterator first，iterator last）//删除一个范围
int n = erase(const Key&key);//通过关键字删除，删除成功n==1.否则==0

//查找find()
mp.find(1);//返回key所在的迭代器，否则返回end()

//lower_bound(查找第一个大于等于key的值)upper_bound(查找第一个大于key的值)
mp.lower_bound(1);
mp.upper.bound(1);

//是否出现count(返回某一key值出现次数,map中使用此函数只会返回1或0)
int a = mp.count(1);

算法algorithm

• 头文件#include <algorithm>

//快速排序sort() //稳定排序stable_sort()
sort(start，end，排序方法);

//反转容器reserve(）
reserve(vec.begin(),vec.end());

//二分查找lower_bound(),upper_bound()//返回的是位置,前提要有序
int num[6]={1,2,4,7,15,34}; 
sort(num,num+6);
int pos1=lower_bound(num,num+6,7)-num;    //返回数组中第一个大于或等于被查数的值 
int pos2=upper_bound(num,num+6,7)-num;    //返回数组中第一个大于被查数的值

//集合操作(前提容器序列有序)
//指定部分是否包含，递增序列使用less<int>(),递减序列使用greater<int>()。
includes(s1.begin(), s1.end(), s2.begin(), s2.end());
//求并集，并输入到支持insert操作的s3中，也可以使用back_inserter(s3)输入到支持push_back操作的s3
set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s3));
//求交集
set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s3));
//求差集
set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s3));


//堆操作
make_heap(begin(),end());//对一个序列建立一个堆，默认大根堆，greater<int>()则是小根堆
pop_heap(begin(),end());//将堆顶元素移到序列末尾，一般搭配pop_back();使用
push_heap(begin(), end());//有新元素插入序列末尾后的加入操作。