今天在寫poj上的一道題時，提交之後顯示程式碼執行超時，查了一下網上都說因為測試資料量大，普通迴圈查詢很容易超時，用優先佇列能解決問題，有時題目裡設計到的狀態資訊比較複雜，要用一個類來維護，類的過載運算子自從上學期學過之後我就忘光了，於是現在寫一篇部落格好好記錄一下：

C++中類的過載運算子

我們知道int可以比較，類和類之間只要通過過載運算子，也可以通過 >, <等方式來比較大小。

一般過載運算子有兩種方式，我直接上程式碼，程式碼裡面都有詳細註釋：

#include<iostream>
#include<algorithm>
#include<queue> 
 

using namespace std;
class Node{
    public:
        int a, b;
    //這是過載運算子解除安裝類內部的寫法，效果與外部一樣，從小到大都是<。 
    //ps：第一行最後的const如果只用sort可以不加，用priority_queue的話
    //    就要加上，還是養成習慣都加上吧 
    bool operator < (const Node & n) const{
        return a > n.a;
    } 
};
//寫在類宣告的外部，如果是<，從小到大,如果是>，從大到小 
 

/*
bool operator < (const Node &n1, const Node &n2){
    return n1.a < n2.a;
}
*/

上面是兩種過載運算子的方式，一種宣告在內部，引數只需要寫一個，另一個和普通函式一樣宣告的外面，所以比較的兩個物件都需要寫出來。

priority_queue優先佇列

優先佇列可以按照你給定的規則來維護一個佇列，是que的升級版，如果是預設的資料型別,int等，預設的宣告代表了從大到小維護資料，當然也可以從小到大維護，下面是程式碼：

priority_queue<int> pque;
priority_queue<int
 
, vector<int>, greater<int> > pque1; 
priority_queue<Node> pque2;
int main(){
    for(int i = 0; i < 10; i++){
        Node n;
        n.a = i;
        n.b = i;
        test[i] = n;
    }
    sort(test, test + 10);
    cout << "檢測C++中的過載運算子：" << endl;
    for(int i = 0; i < 10; i++){
        cout << "Node " << i << " : " << test[i].a << " : " << test[i].b << endl;
    }

    cout << endl << "-------------------------------------------------" << endl;
    cout << "預設宣告的priority_queue :" << endl; 
    pque.push(3);
    pque.push(5);
    pque.push(1);
    while(pque.size()){
        cout << pque.top() << endl;
        pque.pop();
    }
    //輸出5,3,1,可以看得出，priority_queue是從大到小來取東西的 
    cout << "int, vector<int>, greater<int> 宣告的priority_queue :" << endl; 
    pque1.push(5);
    pque1.push(3);
    pque1.push(4);
    while(pque1.size()){
        cout << pque1.top() << endl;
        pque1.pop();

    }

這裡只展示了pque和pque2的程式碼。

將類和priority_queue結合起來

只要我們在類裡面過載運算子，就可以把類當做普通的資料型別那樣按照指定的大小排列維護在佇列裡面了，下面直接是全部的程式碼和執行結果：

#include<iostream>
#include<algorithm>
#include<queue> 
using namespace std;
class Node{
    public:
        int a, b;
    //這是過載運算子解除安裝類內部的寫法，效果與外部一樣，從小到大都是<。 
    //ps：第一行最後的const如果只用sort可以不加，用priority_queue的話
    //    就要加上，還是養成習慣都加上吧 
    bool operator < (const Node & n) const{
        return a > n.a;
    } 
};
//寫在類宣告的外部，如果是<，從小到大,如果是>，從大到小 
/*
bool operator < (const Node &n1, const Node &n2){
    return n1.a < n2.a;
}
*/
Node test[10];
priority_queue<int> pque;
priority_queue<int, vector<int>, greater<int> > pque1; 
priority_queue<Node> pque2;
int main(){
    for(int i = 0; i < 10; i++){
        Node n;
        n.a = i;
        n.b = i;
        test[i] = n;
    }
    sort(test, test + 10);
    cout << "檢測C++中的過載運算子：" << endl;
    for(int i = 0; i < 10; i++){
        cout << "Node " << i << " : " << test[i].a << " : " << test[i].b << endl;
    }

    cout << endl << "-------------------------------------------------" << endl;
    cout << "預設宣告的priority_queue :" << endl; 
    pque.push(3);
    pque.push(5);
    pque.push(1);
    while(pque.size()){
        cout << pque.top() << endl;
        pque.pop();
    }
    //輸出5,3,1,可以看得出，priority_queue是從大到小來取東西的 
    cout << "int, vector<int>, greater<int> 宣告的priority_queue :" << endl; 
    pque1.push(5);
    pque1.push(3);
    pque1.push(4);
    while(pque1.size()){
        cout << pque1.top() << endl;
        pque1.pop();

    }
    cout << "搭載了過載運算子的類的priority_queue :" << endl;
    for(int i = 0; i < 10; i++){
        Node n;
        n.a = i;
        n.b = i;
        pque2.push(n);
    } 
    while(pque2.size()){
        Node n = pque2.top();
        cout << "Node a: " << n.a << ", Node b: " << n.b << endl;
        pque2.pop(); 
    }
    //可以看到，用了prioroty_queue排序過的和用sort排序過的完全相反，
    //所以可以這麼向，如果過載運算子函式裡用<，那麼排序後這個陣列就是
    //從小到大排列的，但是priority_queue是重大到小這麼取的，但是如果只有
    //排序功能的話，priority_queue還有什麼必要存在呢，正是因為它既能夠按照
    // 給定的規則來維護順序，又能夠快速的訪問或是移除元素從而進行高效操作，才存在的 
}