C++STL 泛型库总结

vector

头文件：#include <vector>
创建

vector<int> v;
vector<int> v(10);//存储10个int型元素
vector<double> v(10,8.6);//10个元素，每个元素值为8.6

尾部添加

v.push_back(x);//相当于
v.insert(v.end(),x);

下标访问

vector<int> v(3);
cout<<v[0];

迭代器访问

vector<int>::iterator it;
for(it=v.begin();it!=v.end();it++)
{
	cout<<*it<<" ";
}
cout<<endl;

插入

v.insert(v.begin()+x,y);//在第x个元素前面加入y（从0开始计数）结果v[x]=y

删除

v.erase(v.begin()+x);//删除第x个元素（从0开始计数）同上
v.erase(v.begin()+x,v.begin()+y);//删除第x到第y个区间所有的，不包括第y个（从0开始计数）同上

反向排列

#include <algorithm> 
reverse(v.begin(),v.end());

排序

#include <algorithm> 
sort(v.begin(),v.end());

//还可以自己写比较函数,下面这个是由大到小
bool Comp(const int &a,const int &a)
{
	if(a!=b)
	{
		return a>b;
	}else{
		return a>b; 
	}
}
sort(v.begin(),v.end(),Comp);

清除以及大小

v.size();
v.empty();//为空返回1
v.clear();//清空

string

之前总结过->https://blog.csdn.net/frothmoon/article/details/90318948

set

• 平衡二叉检索树，在插入元素时，就会自动将元素按键值由小到大顺序排列
• 不包含重复的元素，两次插入只有一个键值

头文件：#include <set>
创建

set<T> s;

插入

s.insert(1);

反向迭代

set<int>::reverse_iterator rit;
for(rit=s.rbegin();rit!=s.rend();rit++)
{
	cout<<*rit<<" ";
}
cout<<endl;

删除元素

s.erase(x);//删除键值为x的元素
s.clear();//清空

大小

s.size();

查找

set<int>::iterator it;
it=s.find(x);
if(it!=s.end())//找到

自定义比较

//重载()操作符,下面的是由大到小
struct myComp
{
	bool operator()(const int &a,const int &b)
	{
		if(a!=b)
		{
			return a>b;
		}else{
			return a>b;
		}
	}
};

set<int,myComp> s;
//插入元素
//此时遍历顺序为由大到小

//另一种
struct Info
{
	string name;
	float score;
	//重载“<”,下面是由大到小，由小到大吧“>”
	bool operator < (const Info &a) const
	{
		return a.score<score;
	}	
};
set<Info> s;

multiset

• 与set的头文件相同，内容相近
• 区别是允许重复的元素插入

删除

multiset<string> ms;
ms.insert("123");
int n=ms.erase("123");//返回删除的个数，会把这个值的元素都删除

查找

multiset<string>::iterator it;
it=find("123");//存在多个返回第一个
if(it!=ms.end())//找到

map

头文件：#include <map>
插入结构成对，分为键值和映照数据，插入的键值不允许重复，比较函数只对元素键值比较
map与set都是红黑树结构
创建、插入、遍历、删除

map<string,float> m;
m['HCY']=100.0;//HCY是键值，100是映照数据
map<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
	cout<<(*it).first<<" "<<(*it).second<<endl;
}
m.erase("HCY");//参数是键值

反向遍历与查找省略，与上面介绍过的类似
自定义比较与set相同
数字分离
设有键值对如下：map<char,int>
‘0’:0
‘1’:1
‘2’:2
‘3’:3
可以通过

for(int i=0;i<4;i++)
{
	m['0'+i]=i;
}

实现
选择几个相加s="13";

int sum=0;
for(int i=0;i<s.length();i++)
{
	sum+=m[s[i]];
}

char和int反过来也可以实现

multimap

• 与map头文件相同
• 可以插入重复键值

插入、删除

m.insert(pair<string,double>("HCY",100));
m.erase("HCY");//多个会同时删除

查找与上面相同

dequeue

• 双端队列与vector一样线性存储
• 头部和尾部都可以插入和删除元素
• insert插入会覆盖原来的
• 用法很多同vector

插入、遍历、删除

d.push_back(x);//尾部插入
d.push_front(x);//头部插入
d.push_back(x);//尾部删除
d.push_front(x);//头部删除

//支持以数组的方式遍历
for(i=0;i<d.size();i++)
{
	cout<<d[i]<<" ";
}
//上面的迭代器也适用
d.erase(d.begin()+x);
d.clear();

list

头文件：#include <list>
创建、插入、删除

list<int> l(n);//可带大小可不带
l.push_back(2);
l.push_front(1);
l.pop_back();//删除链表尾元素
l.pop_front();//删除链表首元素

list<int>::iterator it;
it=l.begin();
it++;//迭代器只能++，--不能+n
l.insert(it,100);

it=l.begin();
it++;//迭代器只能++，--不能+n
l.erase(it);

l.remove(x);//删除所有的x
l.clear();//清空

遍历以及反向遍历省略
查找

list<int>::iterator it;
it=find(l.begin(),l.end(),x);//找x
if(it!=l.end())//找到

排序

#include <algorithm> 
l.sort();

剔除重复元素

l.unique();//只保留一个

stack

写不动了直接甩函数了。。。

#include <stack>

stack<int> s;
s.push(1);
s.top();
s.pop();
s.empty();
s.size();

while(s.empty()!=true)
{
	cout<<s.top()<<" ";
	s.pop();
}

queue

#include <queue>

queue<int> q;
q.push(1);
q.pop();//队首出队
q.empty();
q.size();
q.front();//读队首
q.back();//读队尾

while(q.empty()!=true)
{
	cout<<q.front()<<" ";
	q.pop();
}

priority_queue

头文件和queue相同

#include <queue>

priority_queue<int> q;
q.push(1);
q.pop();//队首出队
q.empty();
q.size();
q.top();//读队首

while(q.empty()!=true)
{
	cout<<q.top()<<" ";
	q.pop();
}

优先级定义

//重载()操作符
struct myComp
{
	bool operator()(const int &a,const int &b)
	{
		//这里由小到大是>,由大到小是<
		return a>b;
	}
};
//显示说明结构是vector
priority_queue<int,vector<int>,myComp> q;
//插入元素
//此时遍历顺序为由小到大

//另一种
struct Info
{
	string name;
	float score;
	//重载“<”,下面是由小到大，由大到小用“>”
	bool operator < (const Info &a) const
	{
		return a.score<score;
	}	
};
priority_queue<Info> q;