STL容器——優先隊列

優先隊列

在隊列基礎上按優先級順序進入隊列

0.頭文件#include <queue>

greater和less的優先級比較（和自定義的作用一樣），在頭文件#include <functional>裏

1.創建一個優先級隊列時有兩種申請方式：

priority_queue<ElemType>q或者priority_queue<ElemType,vector<ElemType>,greater<ElemType> >q，

第一種默認的東西比較多，比如底層的實現方式以及堆的性質；

第二種就說明的比較清晰了，第一個參數是隊列中元素的類型；第二個就是隊列底層的實現方式，這裏是用vector實現的；第三個是堆的性質，greater對應小頂堆，less對應大頂堆，當然這兩個只能適用於一些基本類型，於是優先級就是這些基本類型元素的大小。

如果遇到一些複雜的類型，比如結構體或類，那麼就要重新定義這個優先級，於是便要重載bool operator()，或者重載<。

例如：

聲明優先隊列 priority_queue<int>q;//這是默認的優先級順序

也可以直接對於結構體 priority_queue<node>q[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<n2.x，n2的x小，對應的優先級高

就是重載  <  

若a>b，表示小的優先級高

若a<b，表示大的優先級高

理解！記住啊。。

有時候出現其他約束條件

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<n2.pri;
    }
};

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

</pre><pre name="code" class="cpp">#include <iostream>
#include <queue>//優先隊列頭文件
#include <cstdio>
#include <functional>//含有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 x<a.x;//最大值有先
    }
};
struct node3
{
    int x;
    friend bool operator <(node3 n1,node3 n2)//重載：含義是如果pri不同，則pri大的優先級高；如果相同，則看num，num小的優先級高
    {
      return n1.x>n2.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.pri<n2.pri;
    }
};
//第二種定義比較結構
struct cmp1
{
    bool operator ()(int &a,int &b)
    {
        return a>b;//最小值優先
    }
};
struct cmp2
{
    bool operator ()(int &a,int &b)
    {
        return a<b;//最大值優先
    }
};
int a[]= {2,19,5,68,19,99,37,0,50,22};
node1 n1[]= {2,19,5,68,19,99,37,0,50,22};
node2 n2[]= {2,19,5,68,19,99,37,0,50,22};
node3 n3[]= {2,19,5,68,19,99,37,0,50,22};
int main()
{
    //默認優先級順序
    priority_queue<int>que;
    //第一種
    priority_queue<node1>que1;
    priority_queue<node2>que2;
     priority_queue<node3>que33;
    //第二種(用自己構造的比較結構體)
    priority_queue<int,vector<int>,cmp1>que3;//最小值
    priority_queue<int,vector<int>,cmp2>que4;//最大值
    //第二種（自帶的）
    priority_queue<int,vector<int>,greater<int> >que5;//和que3作用一樣，最小值
    priority_queue<int ,vector<int>,less<int> >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_queue<int>que;\n");
    while(!que.empty())
    {
        printf("%d ",que.top());
        que.pop();
    }
    printf("\n\n採用結構體自定義優先級方式一\npriority_queue<node1>que1;\n");
    while(!que1.empty())
    {
        printf("%d ",que1.top());
        que1.pop();
    }
    printf("\npriority_queue<node2>que2;\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<int,vector<int>,cmp1>que3;\n");
    while(!que3.empty())
    {
        printf("%d ",que3.top());
        que3.pop();
    }
    printf("\npriority_queue<int,vector<int>,cmp2>que4;\n");
    while(!que4.empty())
    {
        printf("%d ",que4.top());
        que4.pop();
    }
    printf("\n\n採用結構體自定義優先級方式二加一\n採用頭文件/functional/內定義優先級:\n(priority_queue<int,vector<int>,greater<int>greater<int> >que5;\n");
    while(!que5.empty())
    {
        printf("%d ",que5.top());
        que5.pop();
    }
    printf("\n(priority_queue<int,vector<int>,greater<int>greater<int> >que6;\n");
    while(!que6.empty())
    {
        printf("%d ",que6.top());
        que6.pop();
    }
    printf("\n");

    /*
    採用默認優先級順序:
    priority_queue<int>que;
    91 83 56 47 36 22 14 10 7 3

    採用結構體自定義優先級方式一（推薦）
    priority_queue<node1>que1;
    3 7 10 14 22 36 47 56 83 91
    priority_queue<node2>que2;
    91 83 56 47 36 22 14 10 7 3

    採用結構體自定義優先級方式二
    priority_queue<int,vector<int>,cmp1>que3;
    3 7 10 14 22 36 47 56 83 91
    priority_queue<int,vector<int>,cmp2>que4;
    91 83 56 47 36 22 14 10 7 3

    採用結構體自定義優先級方式二加一
    採用頭文件/functional/內定義優先級:
    (priority_queue<int,vector<int>,greater<int>greater<int> >que5;
    3 7 10 14 22 36 47 56 83 91
    (priority_queue<int,vector<int>,greater<int>greater<int> >que6;
    91 83 56 47 36 22 14 10 7 3


    */

    return 0;
}