STL简介

1.容器类

是容纳、包含一组元素或元素集合的对象；

向量（vector） 双端队列（deque） 列表（list） 集合（set）、多重集合（multiset） 映射（map）和多重映射（multimap）

容器分类
a序列式容器
每个元素都有固定位置－－取决于插入时机和地点，和元素值无关，vector、deque、list；
b关联式容器
元素位置取决于特定的排序准则，和插入顺序无关set、multiset、map、multimap；

容器的相关操作

swap用于提高赋值操作效率与迭代器（iterator）相关的操作

begin()－返回一个迭代器，指向第一个元素

end()－返回一个迭代器，指向最后一个元素之后

rbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素

rend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后

insert(pos,e): 将元素e的拷贝安插于迭代器pos所指的位置

erase(beg,end): 移除[beg，end]区间内的所有元素

clear(): 移除所有元素

vector和数组区别

1.array 定义的时候必须定义数组的元素个数;而vector 不需要；
2.array 定义后的空间是固定的了，不能改变；而vector 要灵活得多，可再加或减.
3.vector有一系列的函数操作，非常方便使用。
4.数组和vector不同，一个数组不能用另一个数组初始化，也不能将一个数组赋值给另一个数组；

set和multiset
内部的元素依据其值自动排序

在vector,list, deque几个容器中插入数据元素时，插入的位置是确定的（最前，最后或是指定的某个位置上）

而在关联容器中插入数据时，根据插入数据元素的大小确定插入的位置(根据对象所属类中定义的（重载的）比较函数)

set内的相同数值的元素只能出现一次，

multiset内可包含多个数值相同的元素，

内部由二叉树（二叉链表，平衡二叉树，默认升序）实现，便于查找；

map

它提供一对一（其中第一个可以称为key，每个关键字只能在map中出现一次，第二个可称为value）的数据处理能力

map<int , char> m;
m.insert(pair<int, char>(1,'1'));
m.insert(pair<int ,char>(1,'2'));
cout<<m.size();
return 0;

map和set比较
共同点
由二叉树（二叉链表）实现，便于查找（这与set）；
区别
于map中的每个节点存储的是一对信息，包括一个key和一个value ，各个节点之间的key的值（第一列的值）不能重复(重复的值自动删除)。
对于set中的每个节点存储的是一个信息，只有一个键，但是每个键值也是唯一的。set表示的是集合的概念。

比赛又开始了。看见到处都是气球升起，多激动啊！告诉你一个秘密：裁判正在非常开心地猜测哪一题最受欢迎。当比赛结束时，他们统计每种颜色气球的数量就知道结果了。
输入
输入有多组测试例。
对每个测试例，第一个数字是N（0＜N＜1000），表示气球的数量。接下来N行，每行是一个气球的颜色，由小写字母构成的字符串表示，长度不超过15个。当N＝0时，表示输入结束。
输出
对每个测试例输出一行，是表示最受欢迎的题目的气球颜色。


#include <iostream>
#include <map>
#include <iterator>
#include <string>
using namespace std;
int main(){
  int n, iMax=0;
   while(cin>>n&& n>0){
   map<string,int > Balloon;
   string s;
   for(int i=0;i<n;i++){   cin>>s;  Balloon[s]++;}
   map<string,int >::iterator point,loc;
   for(point=Balloon.begin();point!=Balloon.end();point++)
   if(iMax<point->second){
   Max=point->second;loc=point;}
   cout<<loc->first<<endl;
  }    
    return 0; 
}

2.迭代器

提供了访问容器中对象的方法。（也可以用其他方法访问容器中的对象）
迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。

3.算法

是用来操作容器中的数据的函数模板。

4.函数对象

所谓函数对象(function object)是重载了函数调用操作符(funiton-call operator()）的对象，函数对象的优势在于能很好的满足STL的抽象要求

5.适配器

将一个class的接口转换为另一个class的接口，使得原本因接口不兼容而不能合作的classes可以一起运作。

优先队列
优先队列是一种比较常用的结构,
普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。
在优先队列中，元素被赋予优先级。
优先级队列内部的元素并不是按照添加的顺序排列，而是自动依照元素的权值排列, 权值最高者排在最前面。默认情况下，优先级队列利用一个大顶堆(优先级高)完成。

优先队列的默认的处理过程：

要建的大顶堆
入队时：将要插入的数据插入在vector 最后，将存储结构处理成完全二叉树（堆），新插入的结点肯定为叶子结点。从叶子结点向树根进行调整，将其调整为“大顶”堆（优先级高的位于堆顶）。

将堆中元素（第一个操作数）与入队的元素（第二个操作数）进行比较，如果less(比较方式)的结果是true（要入队的元素优先级高），则插入的元素向堆顶方向进行移动。

出队时：最大值（优先级）出队

要改变优先关系（比如，最小值的优先级最高）

方法一：改变比较函数
int main(){
       priority_queue<int,vector<int>, greater<int> > q;
       q.push(0);      q.push (10);   q.push(5);      q.push (2);
       while(!q.empty())   {
              int x;
              x=q.top(); q.pop();
              cout<<x<<"   ";
   }
       cout<<endl;
       return 0;
}




       方法二：重载数据元素的<运算符       
class Student{
       char name[10];
       char num[10];
       int score;
public:
       Student( ){}
       Student(
char *name, char *num, int score)      {
              strcpy(this->name,name);
              strcpy(this->num,num);
              this->score=score;
       }
       friend bool operator <(Student s1,Student s2)   //只能重载友元函数，不能被重载成成员函数；或者是常成元函数
       {      return s1.score<s2.score;  //降序排序     }//第一个操作数是堆中最后一个元素， 第二个操作数是插入的元素
       void display()
        {cout<<name<<"\t"<<num<<"\t"<<score<<endl; }
};

本题要求建立和遍历二叉树。
编写程序：给出一组二叉树，实现按层遍历每棵树。本题中二叉树的每个结点都是一个正整数，并且所有的二叉树都不超过256个结点。


  
#include <iostream>      
#include <string>
#include <queue>  
using namespace std;
class Node {  
      string value, path;  
public: 
      void set(string v, string p)
      {    value=v;   path=p; } 
 string get_v()
   {     return value; }  
bool operator <(Nodenode) const {        
if(path.length()>node.path.length())
return true;       
else   
if(path.length()==node.path.length())  
return path>node.path;   
else  
return false;  
}  
};
int main(){
       string node,value,path;  
       Node N;
       priority_queue<Node> q;   
       int index1,index2;   
       while(cin>>node)      {  
              index1=node.find_first_of(',');
              value=node.substr(1,index1-1);     
              index2=node.find_first_of(')');  
              path=node.substr(index1+1,index2-index1-1);
              N.set(value,path);
              q.push(N);  
       }
       while(!q.empty ())      {
              N=q.top();    q.pop(); 
              cout<<N.get_v ()<<"  ";   
       }
       cout<<endl; return 0; }