STL容器——优先队列

优先队列

在队列基础上按优先级顺序进入队列

0.头文件#include

greater和less的优先级比较（和自定义的作用一样），在头文件#include 里

1.创建一个优先级队列时有两种申请方式：

priority_queueq或者priority_queue,greater >q，

第一种默认的东西比较多，比如底层的实现方式以及堆的性质；

第二种就说明的比较清晰了，第一个参数是队列中元素的类型；第二个就是队列底层的实现方式，这里是用vector实现的；第三个是堆的性质，greater对应小顶堆，less对应大顶堆，当然这两个只能适用于一些基本类型，于是优先级就是这些基本类型元素的大小。

如果遇到一些复杂的类型，比如结构体或类，那么就要重新定义这个优先级，于是便要重载bool operator()，或者重载<。

例如：

声明优先队列 priority_queueq;//这是默认的优先级顺序

也可以直接对于结构体 priority_queueq[10];//其中struct node{……};

（node n;//声明一个结构体 再   p[b].push(n);//这一种直接将结构体压入队列中）

2.基本操作：

q.empty()         如果队列为空，则返回true，否则返回false

q.size()            返回队列中元素的个数

q.pop()             删除队首元素，但不返回其值

q.top()             返回具有最高优先级的元素值，但不删除该元素

q.push(item)     在基于优先级的适当位置插入新元素

3.除了默认的优先顺序，还可以自定义优先级比较

重载<运算符，重载的是优先级关系，理解一下这个：

struct node1
{
    int x;
    bool operator < (const node1 &n) const
    {
        return x>n.x;//最小值优先（先进先出）
    }

};
struct node3
{
    int x;
    friend bool operator <(node3 n1,node3 n2)//重载：n小的优先级高
    {
      return n1.x>n2.x;
    }
};

x>n.x; 和 n1.x>n2.x;一样，表示的是，n1.x

就是重载  <  

若a>b，表示小的优先级高

若a

理解！记住啊。。

有时候出现其他约束条件

struct node4
{
    int pri;
    int num;
    friend bool operator <(node4 n1,node4 n2)//重载：含义是如果pri不同，则pri大的优先级高；如果相同，则看num，num小的优先级高
    {
        if(n1.pri==n2.pri) return n1.num>n2.num;
        else return n1.pri

看着dalao的说明自己敲了一下，受益匪浅！！

#include 
#include //优先队列头文件
#include 
#include //含有greater 和 less，也可以自己定义cmp比较
using namespace std;
//第一种自定义数据结构
struct node1
{
    int x;
    bool operator < (const node1 &a) const
    {
        return x>a.x;//最小值优先（先进先出）
    }

};
struct node2
{
    int x;
    bool operator < (const node2 &a) const
    {
        return xn2.x;
    }
};
//别的约数条件下，判断优先级
struct node4
{
    int pri;
    int num;
    friend bool operator <(node4 n1,node4 n2)//重载：含义是如果pri不同，则pri大的优先级高；如果相同，则看num，num小的优先级高
    {
        if(n1.pri==n2.pri) return n1.num>n2.num;
        else return n1.prib;//最小值优先
    }
};
struct cmp2
{
    bool operator ()(int &a,int &b)
    {
        return aque;
    //第一种
    priority_queueque1;
    priority_queueque2;
     priority_queueque33;
    //第二种(用自己构造的比较结构体)
    priority_queue,cmp1>que3;//最小值
    priority_queue,cmp2>que4;//最大值
    //第二种（自带的）
    priority_queue,greater >que5;//和que3作用一样，最小值
    priority_queue,less >que6;//和que4作用一样，最大值

    //给所有优先队列赋初值
    for(int i=0; i<10; i++)
    {
        que1.push(n1[i]);
        que2.push(n2[i]);
        que33.push(n3[i]);
    }
    for(int i=0; i<10; i++)
    {
        que.push(a[i]);
        que3.push(a[i]);
        que4.push(a[i]);
        que5.push(a[i]);
        que6.push(a[i]);
    }

    //打印
    printf("采用默认优先级顺序:\npriority_queueque;\n");
    while(!que.empty())
    {
        printf("%d ",que.top());
        que.pop();
    }
    printf("\n\n采用结构体自定义优先级方式一\npriority_queueque1;\n");
    while(!que1.empty())
    {
        printf("%d ",que1.top());
        que1.pop();
    }
    printf("\npriority_queueque2;\n");
    while(!que2.empty())
    {
        printf("%d ",que2.top());
        que2.pop();
    }
    printf("\n\n自定义优先级方式一加一：\n");
     while(!que33.empty())
    {
        printf("%d ",que33.top());
        que33.pop();
    }
    printf("\n\n采用结构体自定义优先级方式二 \npriority_queue,cmp1>que3;\n");
    while(!que3.empty())
    {
        printf("%d ",que3.top());
        que3.pop();
    }
    printf("\npriority_queue,cmp2>que4;\n");
    while(!que4.empty())
    {
        printf("%d ",que4.top());
        que4.pop();
    }
    printf("\n\n采用结构体自定义优先级方式二加一\n采用头文件/functional/内定义优先级:\n(priority_queue,greatergreater >que5;\n");
    while(!que5.empty())
    {
        printf("%d ",que5.top());
        que5.pop();
    }
    printf("\n(priority_queue,greatergreater >que6;\n");
    while(!que6.empty())
    {
        printf("%d ",que6.top());
        que6.pop();
    }
    printf("\n");

    /*
    采用默认优先级顺序:
    priority_queueque;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式一（推荐）
    priority_queueque1;
    3 7 10 14 22 36 47 56 83 91
    priority_queueque2;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式二
    priority_queue,cmp1>que3;
    3 7 10 14 22 36 47 56 83 91
    priority_queue,cmp2>que4;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式二加一
    采用头文件/functional/内定义优先级:
    (priority_queue,greatergreater >que5;
    3 7 10 14 22 36 47 56 83 91
    (priority_queue,greatergreater >que6;
    91 83 56 47 36 22 14 10 7 3


    */

    return 0;
}