优先队列的优先级设置

priority_queue<int> 大顶堆
priority_queue<int, vector<int>, less<int> > 大顶堆：表示其他都比堆顶小 //>和>之间有空格 防止辨认为输入符号
priority_queue<int, vector<int>, greater<int> > 小顶堆：表示其他都比堆顶大

结构体设置优先级：

只可在结构体内部重载小于号。

两种重置用法：

运算符重载 + 友元

struct fruit
{
    string name;
    double price;
    friend bool operator< (fruit f1, fruit f2)
    {
        return f1.price < f2.price; // 相当于less,这是大顶堆，反之则是小顶堆
    }
} f1, f2, f3; //定义三个结构体变量

调用：

priority_queue<fruit>q;

比较运算符外置

struct fruit
{
    string name;
    double price;
} f1, f2, f3; //定义三个结构体变量
struct cmp
{
    bool operator () (fruit f1, fruit f2) // 重载括号
    {
        return f1.price < f2.price; // 等同于less
    }
};

调用：

priority_queue<fruit,vector<fruit>,cmp>q; 
//这个和基本类型的用法就相似了，只不过是用cmp代替了less或greater。

map的用法

基本操作：

begin() 返回指向map头部的迭代器

clear() 删除所有元素

count() 返回指定元素出现的次数

end() 返回指向map末尾的迭代器

map的遍历：

map<int,int>::iterator it;
        for(it=tel.begin();it!=tel.end();it++)
        {
            if(it->second>1)
            {
                printf("%03d-%04d %d\n",it->first/10000,it->first%10000,it->second);
            }
        }     //it->first代表键(key)，it->second代表值(value)

map的一个特性：

我们知道，map内部本身就是按序存储的（比如红黑树），这样方便实现快速查找。在我们插入键值对时，map就会自动按照key的大小顺序进行存储。因而作为key的类型必须能够进行大小运算的比较。比如int、double、string、char等类型。

vector排序

sort(a.begin(), a.end());

用自定义的结构体进行sort算法：

这时候需要自己定义个比较函数，因为sort算法是基于容器中的元素是可以两两比较的，然后从小到大排序，所以要自定义怎么样才是小于（’<’）

//自定义“小于”
bool comp(const student &a, const student &b){
    return a.score < b.score;
}

调用：sort(a.begin(),a.end(),comp);

不过有时候一个排序条件不够，比如要求学生按分数从高到低排序，如果分数相同，则按照年龄从大到小排序

就需要在comp自定义函数里面修改一下判断了，原来是直接return a.score < b.score

现在就需要判断

//自定义“小于”
bool comp(const student &a, const student &b){
    if (a.score > b.score)
        return true;
    else if (a.score == b.score  && a.age > b.age)
        return true;
    else                ///这里的else return false非常重要！！！！！
        return false;
}

vector insert()

v.insert(v.begin(),8);//在最前面插入新元素

v.insert(v.begin()+2,1);//在迭代器中第二个元素前插入新元素 v.insert(v.end(),3);//在向量末尾追加新元素

v.insert(v.end(),4,1);//在尾部插入4个1

Pair

pair是一种模板类型，其中包含两个数据值，两个数据的类型可以不同，基本的定义如下：

pair<int,string>a;

表示a中有两个类型，第一个元素是int型的，第二个元素是string类型的，如果创建pair的时候没有对其进行初始化，则调用默认构造函数对其初始化。

pair<string,string>a("James","Joy");

也可以像上面一样在定义的时候直接对其初始化。

由于pair类型的使用比较繁琐，因为如果要定义多个形同的pair类型的时候，可以时候typedef简化声明：

typedef pair<string,string>author;
author pro("May","Lily");
author joye("James","Joyce");

对于pair类，由于它只有两个元素，分别名为first和second，因此直接使用普通的点操作符即可访问其成员。

pair<string,string>a("Lily","Poly"); 
string name;
name=pair.second;

可以使用make_pair对已存在的两个数据构造一个新的pair类型：

int a=8;
string m="James";
pair<int,string>newone;
newone=make_pair(a,m);

两个pairs互相比较时， 第一个元素正具有较高的优先级.
例：

bool operator< (const pair<T1, T2>&x, const pair<T1, T2>&y)
{return x.first<y.first||((y.first<x.first)&&x.second<y.second);}

List

list<int> c0; //空链表
list<int> c1(3); //建一个含三个默认值是0的元素的链表
list<int> c2(5,2); //建一个含五个元素的链表，值都是2
list<int> c4(c2); //建一个c2的copy链表
list<int> c5(c1.begin(),c1.end()); ////c5含c1一个区域的元素[_First, _Last)

c.assign(n,num) 将n个num拷贝赋值给链表c

c.assign(beg,end) 将[beg,end)区间的元素拷贝赋值给链表c

c.insert(pos,num) 在pos位置插入元素num

c.insert(pos,n,num) 在pos位置插入n个元素num

c.insert(pos,beg,end) 在pos位置插入区间为[beg,end)的元素

c.erase(pos) 删除pos位置的元素

c1.merge(c2) 合并2个有序的链表并使之有序，重新放到c1里，释放c2

c1.merge(c2,comp) 合并2个有序的链表并使之按照自定义规则排序之后从新放到c1中，释放c2

a2.merge(a1,{return n1>n2;});

c1.splice(c1.beg,c2) 将c2连接在c1的beg位置,释放c2

c1.splice(c1.beg,c2,c2.beg) 将c2的beg位置的元素连接到c1的beg位置，并且在c2中施放掉beg位置的元素

c1.splice(c1.beg,c2,c2.beg,c2.end) 将c2的[beg,end)位置的元素连接到c1的beg位置并且释放c2的[beg,end)位置的元素

reverse() 反转链表