C++ STL 容器(3)

一 Queue容器
1 简介
#include <queue>
queue是队列容器，是一种“先进先出”的容器。
queue是简单地装饰deque容器而成为另外的一种容器。

2 queue的push()与pop()方法

queue.push(elem);   //往队尾添加元素
queue.pop();   //从队头移除第一个元素

3 queue的数据存取

queue.back();   //返回最后一个元素
queue.front();   //返回第一个元素

4 queue的大小

queue.empty(); //判断队列是否为空
queue.size(); //返回队列的大小

二 优先级队列priority_queue

#include <iostream>
#include<functional>
using namespace std;
#include "queue"
void main81()
{
priority_queue<int> p1; //默认情况下 是 最大值优先级队列 
priority_queue<int, vector<int>, less<int>> p2; //提前定义好的预定义函数  谓词
priority_queue<int, vector<int>, greater<int> >  p3; //最小值优先级队列
p1.push(33);
p1.push(11);
p1.push(55);
p1.push(22);


cout << "队头元素:" << p1.top() << endl;
cout << "队列的大小:" << p1.size() << endl;
while (p1.size() > 0)
{
	cout << p1.top() << " ";
	p1.pop();
}
cout << "测试 最小值优先级队列 " << endl;
p3.push(33);
p3.push(11);
p3.push(55);
p3.push(22);


cout << " 最小值优先级队列 队头元素:" << p3.top() << endl;
cout << " 最小值优先级队列 队列的大小:" << p3.size() << endl;
while (p3.size() > 0)
{
	cout << p3.top() << " ";
	p3.pop();
}
}
void main()
{
main81();
cout << "hello..." << endl;
system("pause");
return;
}

三List容器
1简介

#include <list>
list是一个双向链表容器，可高效地进行插入删除元素。
list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符。it++(ok) it+5(err)

2 list头尾的添加移除操作

list.push_back(elem);    //在容器尾部加入一个元素
list.pop_back();         //删除容器中最后一个元素
list.push_front(elem);   //在容器开头插入一个元素
list.pop_front();        //从容器开头移除第一个元素

3list的数据存取

list.front();   //返回第一个元素。
list.back();    //返回最后一个元素。

===================

#include<iostream>
#include<list>
using namespace std;
void printList(list<int> *L)
{
cout <<"打印： ";
for (list<int>::iterator itr = L->begin(); itr != L->end(); itr++)
{
	cout << *itr<<"  ";
}
cout << endl;
}
int main()
{
list<int>L;
cout << "list的大小" << L.size() << endl; 
for (int i = 0; i < 10; i++)
{
	L.push_back(i + 1);
}
cout << "list的大小" << L.size() << endl;
printList(&L);
list<int>::iterator it = L.begin();
it++;
it++;
it++;
//it = it + 5;  //不支持随机的访问容器
L.insert(it, 100); //请问100插入在蛇那么位置
printList(&L);
cout << "it==" << *it << endl;
list<int>::iterator it2 = L.begin();
L.erase(it2, it);

printList(&L);
return 0;
}

四set和multiset容器

1 简介
头文件#include <set>
（1)set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。
(2)set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。
(3)set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。
(4)multiset与set的区别：set支持唯一键值，每个元素值只能出现一次；而multiset中同一值可以出现多次。
(5)不可以直接修改set或multiset容器中的元素值，因为该类容器是自动排序的。
如果希望修改一个元素值，必须先删除原有的元素，再插入新的元素。

2 set/multiset对象的默认构造

set<int> setInt;            //一个存放int的set容器。 
set<float> setFloat;     //一个存放float的set容器。 
set<string> setString;     //一个存放string的set容器。 
multiset<int> mulsetInt;            //一个存放int的multi set容器。 
multi set<float> multisetFloat;     //一个存放float的multi set容器。 
multi set<string> multisetString;     //一个存放string的multi set容器。 

3 set的插入与迭代器

² set.insert(elem);     //在容器中插入元素。 
² set.begin(); 		 //返回容器中第一个数据的迭代器。 
² set.end(); 	 	//返回容器中最后一个数据之后的迭代器。 
² set.rbegin(); 	 //返回容器中倒数第一个元素的迭代器。 
² set.rend();   	//返回容器中倒数最后一个元素的后面的迭代器。 
set<int> setInt; 
setInt.insert(3); 
setInt.insert(1);
setInt.insert(5);
setInt.insert(2); 
for(set<int>::iterator it=setInt.begin(); it!=setInt.end(); ++it) 
{ 
	  int iItem = *it; 
  	cout << iItem;    //或直接使用cout << *it 
} 

4 set的删除

set.clear();	//清除所有元素
set.erase(pos);	//删除pos迭代器所指的元素，返回下一个元素的迭代器。
set.erase(beg,end);//删除区间[beg,end)的所有元素,返回下一个元素的迭代器。
set.erase(elem);     //删除容器中值为elem的元素。

五Map和multimap容器
1 简介
#include <map>
（1）map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对。它提供基于key的快速检索能力。
（2）map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。
（3）map的具体实现采用红黑树变体的平衡二叉树的数据结构。在插入操作和删除操作上比vector快。
（4）map可以直接存取key所对应的value，支持[]操作符，如map[key]=value。
（5）multimap与map的区别：map支持唯一键值，每个键只能出现一次；而multimap中相同键可以出现多次。multimap不支持[]操作符。

2 map的添加遍历删除
（1）四种插入方法的异同

 map.insert(...);    //往容器插入元素，返回pair<iterator,bool> 
 在map中插入元素的四种方式： 
假设  map<int, string> mapStu; 
 一、通过pair的方式插入对象 
mapStu.insert(  pair<int,string>(3,"小张")  ); 
二、通过pair的方式插入对象 
mapStu.inset(make_pair(-1, “校长-1”)); 
三、通过value_type的方式插入对象 
mapStu.insert(  map<int,string>::value_type(1,"小李")  ); 
四、通过数组的方式插入值 
	mapStu[3] = “小刘"; 
	mapStu[5] = “小王"；
===========================================================
map<int, string> map1;
//方法1
map1.insert(pair<int, string>(1,"teacher01") );
map1.insert(pair<int, string>(2,"teacher02") );
//方法2 
map1.insert(make_pair(3, "teacher04") );
map1.insert(make_pair(4, "teacher05") );
//方法3 
map1.insert(map<int, string>::value_type(5, "teacher05") );
map1.insert(map<int, string>::value_type(6, "teacher06") );
//方法4
map1[7] = "teacher07";
map1[8] = "teacher08";

（2） 遍历

for (map<int, string>::iterator it = map1.begin(); it!=map1.end(); it++ )
{
	cout << it->first << "\t" << it->second << endl;
}
cout << "遍历结束" << endl;

(3)删除

map.clear();	//删除所有元素
map.erase(pos);	//删除pos迭代器所指的元素，返回下一个元素的迭代器。
map.erase(beg,end);	//删除区间[beg,end)的所有元素，返回下一个元素的迭代器。
map.erase(keyElem);    //删除容器中key为keyElem的对组。
======================
while (!map1.empty())
{
	map<int, string>::iterator it = map1.begin();
	cout << it->first << "\t" << it->second << endl;
	map1.erase(it);
}

3 map的查找
map.find(key); 查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end();
map.count(keyElem); //返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
map.lower_bound(keyElem); //返回第一个key>=keyElem元素的迭代器。
map.upper_bound(keyElem); // 返回第一个key>keyElem元素的迭代器。
map.equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。

//equal_range //异常处理
pair<map<int, string>::iterator , map<int, string>::iterator> mypair = map1.equal_range(5); //返回两个迭代器 形成一个 pair
//第一个迭代器 >= 5的 位置 
//第一个迭代器 = 5的 位置 
if (mypair.first == map1.end() )
{
	cout << "第一个迭代器 >= 5的 位置 不存在" << endl;
}
else
{
	cout << mypair.first->first << "\t" << mypair.first->second << endl;
}
//使用第二个迭代器
if (mypair.second == map1.end() )
{
	cout << "第二个迭代器 > 5的 位置 不存在" << endl;
}
else
{
	cout << mypair.second->first << "\t" << mypair.second->second << endl;
}
}