STL介绍

1.顺序式容器

• vector 动态数组。随机访问频繁，插入删除较少。
• list 双向链表。插入删除频繁，随机访问较少。
• stack 栈。先进后出。
• queue 队列。先进先出。
• priority_queue 优先队列。每一次的 push() 操作，优先级最高的元素都会被放在最前面。
• deque 双向队列。

//头文件
#include <iostream>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>

I.vector

std::vector<int> v;

vector功能	例子	说明
插入	v.insert ( v.begin()+i, k )	在下标为 i 处插入 k
插入末尾	v.push_back ( k )	在末尾插入 k
插入末尾	v.insert ( v.end(), n, k )	在末尾插入 n 个值为 k 的元素
删除	v.erase ( v.begin() + n )	删除下标为 n 的元素( 第 n+1 个)
删除末尾	v.pop_back ()	删除末尾元素
删除区间	v.erase(v.begin()+i,v.begin()+j)	删除下标 [ i, j-1 ] 的元素
查找	v[ i ]	访问下标为 i 的元素。直接访问任何元素
是否为空	v.empty ()	数组为空返回True
大小	v.size ()	数组大小
调整大小	v.resize ( n )	数组大小变为 n. 数组变小则砍掉靠后元素. 数组变大则增加0
调整大小	v.resize ( n, k )	末尾插入 k 使数组大小为 n
当前空间大小	v.capacity ()	当前系统分配的存储空间大小
调整预留空间大小	v.reserve ( n )	设置预留空间大小为 n
互换两个数组	v1.swap ( v2 )	交换两个数组的所有元素
排序	sort ( v.begin(), v.end() )	借用 sort() 递增排序
清空	v.clear ()	清空数组
逆置	reverse ( v.begin(), v.end() )	借用 reverse() 逆置数组

//使用迭代器做简单插入例子
#include <iostream>
#include <vector>

int main (){
	std::vector<int> myvector (3,100); //100 100 100 
	std::vector<int>::iterator it;

	it = myvector.begin();
	it = myvector.insert ( it , 200 ); //200(it) 100 100 100 

	myvector.insert (it,2,300); //300(it) 300 200 100 100 100
	//it已经失效,需要重新赋值
	it = myvector.begin(); 

	std::vector<int> anothervector (3,400); //400 400 400 
	myvector.insert (it+2,anothervector.begin(),anothervector.end()); 
	//300 300 400 400 400 200 100 100 100

	int myarray [] = { 501,502,503 };
	myvector.insert (myvector.begin(), myarray, myarray+3);
	//501 502 503 300 300 400 400 400 200 100 100 100

	std::cout << "myvector contains:";
	for (it=myvector.begin(); it<myvector.end(); it++)
    	std::cout << ' ' << *it;
	std::cout << '\n';

    return 0;
}
}

it = myvector.insert ( it , 200 );//迭代器这样写最好
myvector.insert ( it , 200 );//不要这样写
在vector中使用迭代器插入，不会改变迭代器指向的位置
而在list中使用迭代器插入，指向的位置随之向后移动使得指向的位置改变而指向值不变

II.list

std::list<int> L;

和vector的功能大同小异

III.stack

std::stack<Type> s;

stack功能	例子	说明
插入栈顶	s.push ( item )	把 item 放入栈顶
查找栈顶元素	item = s.top ()	返回值但是不退栈
删除栈顶元素	s.pop ()	退栈但是不返回值
是否为空	s.empty ()	栈为空返回 True
大小	s.size ()	栈大小
互换	s1.swap ( s2 )	交换两个栈的所有元素
插入栈顶	s.emplace ( item )	把item插入栈顶。C++11

IV.queue

std::queue<Type> q;

queue功能	例子	说明
插入队列	q.push ( item )	插入元素 item
查找队首	item = q.front ()	返回队首元素
查找队尾	q.back ()	返回队尾元素
删除队首	q.pop ()	删除队首但是不返回值
是否为空	q.empty ()	队列为空返回 True
大小	q.size ()	队列大小
交换	q1.swap( q2 )	交换两个队列的所有元素
插入队列	q.emplace ( item )	把item插入队列。C++11

V.priority_queue

std::priority_queue<Type> pq;

priority_queue功能	例子	说明
插入队列	pq.push ( item )	插入元素 item
查找队首	item = pq.top ()	返回队首元素
删除队首	pq.pop ()	删除队首但是不返回值
是否为空	pq.empty ()	队列为空返回 True
大小	pq.size ()	队列大小
交换	pq1.swap( pq2 )	交换两个队列的所有元素
插入队列	pq.emplace ( item )	把item插入队列。C++11

2.关联式容器

• set 集合
• multiset 快速查找
• map 一对一映射
• multimap 一对多映射

//头文件
#include <iostream>
#include <set>
#include <map>

I.set

std::set<int> s;

set功能	例子	说明
插入队列	s.insert ( item )	插入元素 item
删除元素	s.erase ( item )	删除元素 item
删除元素	s.erase ( it )	删除迭代器指向的元素
删除元素	s.erase ( it1, it2 )	删除两个迭代器中间的的元素，左闭右开
是否为空	s.empty ()	set 为空返回 True
大小	s.size ()	队列大小
清空	s.clear ()	清空 set
寻找	it = s.find ( item )	返回一个迭代器指向 item
	s.lower_bound ( item )	返回一个迭代器，指向健值大于等于item的第一个元素
	s.upper_bound ( item )	返回一个迭代器，指向健值大于item的第一个元素
判断存在	s.count ( item )	如果set中存在 item， 返回1；否则返回0

II.map

template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

map是一种关联式存储器，存储的是<key value, mapped value>对的联合体，并且有一定的排序。
通常 key 被用来排序，并且被唯一确定 map 中的元素；而 mapped value 存储内容。key 和 mapped value 一般是不同类型的数据，用 value_type 统一表示，如下所示：
typedef pair<const Key, T> value_type;
排序时，map 中的元素总是通过 key 并且按照一个特殊可自定义标准来排序，这个标准用 Compare 类的内部比较对象定义。
map 中的 mapped values 也可以直接被访问到通过重载 operator[] 来访问相关 key。
参考

---

特性：
关联性。关联性容器中的元素可以通过 key 来访问，而不是通过在容器中的绝对位置。
有序性。容器中的元素在任何时刻都严格有序。所有元素在插入时都会按照顺序被放在一定的位置。
内部联合。每一个元素都是一个 key 联合一个 mapped value：通过 key 来确认内容 mapped value。
key 唯一。不会有两个元素拥有相同的 key。
自定义分配。我们可以通过一个 allocator 对象来动态处理存储需要。

---

下面是通过小例子给出功能：

#include<iostream>
#include<map>
using namespace std;
int main (){
	std::map<int, char> student; //存储学生的ID和性别
	//插入
	student.insert( std::pair<int, char>(1,'M'));//通过insert插入 
	student.insert( std::pair<int, char>(2,'F'));
	student[3] = 'M';//通过key插入 
	student[4] = 'F';
	student[5] = 'M';
	student[6] = 'F';
	student[7] = 'M';
	student[8] = 'F';
	
	//删除
	student.erase(5);//通过key删除 
	std::map<int, char>::iterator it = student.find(6);
	student.erase(it);//通过迭代器it删除
	it = student.find(7);
	student.erase(it, student.end());//通过范围删除
	
	//查询
	for(it=student.begin(); it!=student.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';//通过迭代器查询 
	std::cout<<student[2]<<'\n'; //通过key查询 
	std::cout<<'\n';
	int id = student.find(1)->first;//通过find()查询 
	char sex = student.find(1)->second;
	
	//大小
	int len = student.size();
	
	//是否为空
	bool emp = student.empty();
	
	//查询是否存在某个元素 
	bool exist = student.count(3); //通过key查询
	
	//插入emplace.C++11
//	student.emplace('5','M');
//	student.emplace('6','F');
	
	//从后往前
	std::map<int, char>::reverse_iterator rit;
	for(rit=student.rbegin(); rit!=student.rend(); rit++)
		std::cout<< rit->first <<"=>"<< rit->second <<'\n'; 
	std::cout<<'\n';
	
	//按照key排序，第三个参数控制。默认是less<Key>就是升序。greater<>就是降序 
	std::map<int, char, greater<int> > man;
	man[5] = 'F';
	man[1] = 'F';
	man[2] = 'F';
	man[4] = 'M';
	man[3] = 'F'; 
	for(it=man.begin(); it!=man.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout<<'\n';
	
	//交换swap.排序不一样不能交换
	std::map<int, char> worker;
	worker[10]='a';worker[11]='b';worker[12]='c';
	student.swap(worker);
	std::cout << "student contains:\n";
	for(it=student.begin(); it!=student.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout << "worker contains:\n";
	for(it=worker.begin(); it!=worker.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout<<'\n';
	student.swap(worker);
	
	//key_comp()比较两个参数顺序是否符合map的顺序。符合返回true 
	std::map<int, char>::key_compare studentkey_comp = student.key_comp(); 
	it = student.begin();//<1,M>
	do{
		std::cout<<it->first<<" "<<it->second<<'\n'; //输出前三个 
	}while( studentkey_comp( (*it++).first, student.find(3)->first ) );
	std::cout<<'\n';
	
	//value_comp()整体比较 
	std::pair<int, char> last = *student.rbegin()++;
	it = student.begin();
	do{
		std::cout<<it->first<<"=>"<<it->second<<'\n'; 
	}while( student.value_comp()(*it++, last) );
	std::cout<<'\n';
	
	//清空map
	student.clear();
	
	return 0;
}