C++ 类的重载运算符和priority_queue综合使用

今天在写poj上的一道题时，提交之后显示代码运行超时，查了一下网上都说因为测试数据量大，普通循环查找很容易超时，用优先队列能解决问题，有时题目里设计到的状态信息比较复杂，要用一个类来维护，类的重载运算符自从上学期学过之后我就忘光了，于是现在写一篇博客好好记录一下：

C++中类的重载运算符

我们知道int可以比较，类和类之间只要通过重载运算符，也可以通过 >, <等方式来比较大小。

一般重载运算符有两种方式，我直接上代码，代码里面都有详细注释：

#include
#include
#include 
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 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, greater 声明的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
#include
#include 
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 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, greater 声明的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还有什么必要存在呢，正是因为它既能够按照
    // 给定的规则来维护顺序，又能够快速的访问或是移除元素从而进行高效操作，才存在的 
}