C++ STL 容器整理

顺序性容器

一.<Vector>

Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。

1.构造
vector<int> v1; //构造一个空的vector
vector<int> v1( 5, 42 ); //构造了一个包含5个值为42的元素的Vector

2.back() 返回最末一个元素

3.begin() 返回第一个元素的迭代器

4.clear() 清空所有元素

5.empty() 判断Vector是否为空

6.insert() 插入元素到Vector中

语法：
iterator insert( iterator loc, const &val );
//在指定位置loc后插入值为val的元素,返回指向这个元素的迭代器,
void insert( iterator loc, size_type num, const  &val );
//在指定位置loc后插入num个值为val的元素
void insert( iterator loc, input_iterator start, input_iterator end );
//在指定位置loc后插入区间[start, end)的所有元素       

7. erase() 删除指定元素

语法：
iterator erase( iterator loc );//删除loc处的元素
iterator erase( iterator start, iterator end );//删除start和end之间的元素

8.pop_back() 移除最后一个元素

9.push_back() 在Vector最后添加一个元素

10.size() 返回Vector元素数量的大小

11.swap() 交换两个Vector
语法：
void swap( vector &from );

#include <iostream>
#include <cstdio>
#include <numeric>
#include <vector>
using namespace std;
vector<int> v;
int a[100];

int main()
{
	for (int i=1;i<=10;i++)
		{v.push_back(i);//把元素入v 
		 a[i]=i;}
	vector<int> ::iterator it;
	for (it=v.begin();it!=v.end();it++)//遍历每一个元素 
		cout<<*it<<ends;
	cout<<endl<<accumulate(v.begin(),v.end(),0)<<endl;//求v.begin()到v.end()的和
	
	v.insert(it,10); //在it后插入10 
	v.insert(it,10,25); //在it后插入10个25 
	v.insert(it,a+1,a+10); //在it后插入a[1...9]中的所有元素
	 
	v.erase(it);//必须用迭代器it，但还不能给it赋值为数字，故需用for把it赋值 
	v.erase(--it,it);//删除it前一位到it的元素
	
	for (it=v.begin();it!=v.end();it++)//遍历每一个元素 
		cout<<*it<<ends;

	return 0;
}

关联容器

set 又称集合，实际上就是一组元素的集合，但其中所包含的元素的值是唯一的，且是按一定顺序排列的，集合中的每个元素被称作集合中的实例。因为其内部是通过链表的方式来组织，所以在插入的时候比vector 快，但在查找和末尾添加上比vector 慢。

multiset 是多重集合，其实现方式和set 是相似的，只是它不要求集合中的元素是唯一的，也就是说集合中的同一个元素可以出现多次。
map 提供一种“键- 值”关系的一对一的数据存储能力。其“键”在容器中不可重复，且按一定顺序排列（其实我们可以将set 也看成是一种键- 值关系的存储，只是它只有键没有值。它是map 的一种特殊形式）。由于其是按链表的方式存储，它也继承了链表的优缺点。
multimap 和map 的原理基本相似，它允许“键”在容器中可以不唯一。

二. <Sets> &< MultiSets>
集合(Set)是一种包含已排序对象的关联容器。多元集合(MultiSets)和集合(Sets)相像，只不过支持重复对象,其用法与set基本相同。
1.begin() 返回指向第一个元素的迭代器

2.clear() 清除所有元素

3.count() 返回某个值元素的个数

4.empty() 如果集合为空，返回true

5.end() 返回指向最后一个元素的迭代器

6.erase() 删除集合中的元素

语法:
iterator erase( iterator i ); //删除i位置元素
iterator erase( iterator start, iterator end );
//删除从start开始到end(end为第一个不被删除的值)结束的元素
size_type erase( const key_type &key );
//删除等于key值的所有元素（返回被删除的元素的个数）

//前两个返回第一个不被删除的双向定位器,不存在返回末尾
//第三个返回删除个数
7.find() 返回一个指向被查找到元素的迭代器
语法:
iterator find( const key_type &key );
//查找等于key值的元素，并返回指向该元素的迭代器;
//如果没有找到,返回指向集合最后一个元素的迭代器
8.insert() 在集合中插入元素
语法:
iterator insert( iterator i, const TYPE &val ); //在迭代器i后插入val
void insert( input_iterator start, input_iterator end );
//将迭代器start开始到end（end不被插入）结束返回内的元素插入到集合中
//应该注意的是在集合(Sets中不能插入两个相同的元素)

9.lower_bound() 返回指向大于（或等于）某值的第一个元素的迭代器
语法:
iterator lower_bound( const key_type &key );
//返回一个指向大于或者等于key值的第一个元素的迭代器

10.upper_bound() 返回大于某个值元素的迭代器
语法:
iterator upwer_bound( const key_type &key );
//返回一个指向大于key值的第一个元素的迭代器

11.size() 集合中元素的数目

12.swap() 交换两个集合变量
语法:
void swap( set &object ); //交换当前集合和object集合中的元素

三.<Maps> & <MultiMaps>

1.begin() 返回指向map头部的迭代器
2.clear() 删除所有元素
3.count() 返回指定元素出现的次数
语法:
size_type count( const KEY_TYPE &key );
//返回map中键值等于key的元素的个数
4.empty() 如果map为空则返回true
5.end() 返回指向map末尾的迭代器
6.erase() 删除一个元素
语法:
void erase( iterator i ); //删除i元素
void erase( iterator start, iterator end ); //删除从start开始到end（不包括end）结束的元素
size_type erase( const key_type &key );
//删除等于key值的所有元素（返回被删除的元素的个数）
7.find() 查找一个元素
语法:
iterator find( const key_type &key );
//查找等于key值的元素，并返回指向该元素的迭代器;
//如果没有找到,返回指向集合最后一个元素的迭代器.
9.insert() 插入元素
语法:
iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val );
//插入val到pos的后面，然后返回一个指向这个元素的迭代器
void insert( input_iterator start, input_iterator end );
//插入start到end的元素到map中
10.lower_bound() 返回键值>=给定元素的第一个位置
语法:
iterator lower_bound( const key_type &key );
//返回一个指向大于或者等于key值的第一个元素的迭代器

11.upper_bound() 返回键值>给定元素的第一个位置

语法:
iterator upwer_bound( const key_type &key );
//返回一个指向大于key值的第一个元素的迭代器
12.size() 返回map中元素的个数

13.swap() 交换两个map
语法:
void swap( map &obj );
//swap()交换obj和现map中的元素

容器适配器

STL 中包含三种适配器：栈stack 、队列queue 和优先级priority_queue 。
STL 中提供的三种适配器可以由某一种顺序容器去实现。默认下stack 和queue 基于deque 容器实现，priority_queue 则基于vector 容器实现。当然在创建一个适配器时也可以指定具体的实现容器，创建适配器时在第二个参数上指定具体的顺序容器可以覆盖适配器的默认实现。
由于适配器的特点，一个适配器不是可以由任一个顺序容器都可以实现的。
栈stack 的特点是后进先出，所以它关联的基本容器可以是任意一种顺序容器，因为这些容器类型结构都可以提供栈的操作有求，它们都提供了push_back 、pop_back 和back 操作。
队列queue 的特点是先进先出，适配器要求其关联的基础容器必须提供pop_front 操作，因此其不能建立在vector 容器上。

四.<Stacks>

1.empty() 堆栈为空则返回真

2.pop() 移除栈顶元素

3.push() 在栈顶增加元素

4.size() 返回栈中元素数目

5.top() 返回栈顶元素

五.1.<queues>

1.back() 返回一个引用，指向最后一个元素
2.empty() 如果队列空则返回真
3.front() 返回第一个元素
4.pop() 删除第一个元素
5.push() 在末尾加入一个元素
6.size() 返回队列中元素的个数

五.2.priority_queues

1.empty() 如果优先队列为空，则返回真

2.pop() 删除第一个元素

3.push() 加入一个元素

4.size() 返回优先队列中拥有的元素的个数

5.top() 返回优先队列中有最高优先级的元素

struct cmp1
{  
    bool operator ()(int &a,int &b)
	{  
        return a>b;//最小值优先   
    }  
};  
struct cmp2
{  
    bool operator ()(int &a,int &b)
	{  
        return a<b;//最大值优先   
    }  
};  
struct node1
{  
    int u;  
    bool operator < (const node1 &a) const 
	{  
       return u>a.u;//最小值优先   
    }  
};  
struct node2
{  
	int u;  
	bool operator < (const node2 &a) const 
	{  
        return u<a.u;//最大值优先   
	}  
}; 

priority_queue<int>q1;//采用默认优先级构造队列     
priority_queue<int,vector<int>,cmp1>q2;//最小值优先   
priority_queue<int,vector<int>,cmp2>q3;//最大值优先   
priority_queue<int,vector<int>,greater<int> >q4;//注意“>>”会被认为错误，   
                                                //这是右移运算符，所以这里用空格号隔开,最小值优先 
priority_queue<int,vector<int>,less<int> >q5;//最大值优先    
priority_queue<node1>q6;  //自定义优先级
priority_queue<node2>q7;

++++++++++++++++本文修改自《C++ 标准模板库（STL）》，感谢其作者++++++++++++++++++++