Question

我的priority_queue是向后排序的，我不明白为什么。这来自cplusplus.com

表达式comp（a，b），其中comp是这种类型的对象和a 和b是容器中的元素，如果 a，则返回 true 考虑在b 之前在严格的弱函数中排序定义

现在在我的Comparator的类operator（）函数中，如果a小于b，则a应该在b之前。因此，如果a小于b，则返回true。但最后我得到序列“321”，但我反而选择了“123”！

#include <iostream>
#include <queue>
using namespace std;

class Number{
    int x;
public:
    Number(int _x):x(_x){}
    int getX()const{return x;}
};

class Comparator{
public:
    bool operator()(const Number& a,const Number& b){
        if (a.getX()<b.getX()){
            return true;
        } else {
            return false;
        }
    }
};

int main(){
    priority_queue<Number,vector<Number>,Comparator> pq;
    pq.push(2);
    pq.push(1);
    pq.push(3);

    while (!pq.empty()){
        cout<<pq.top().getX();
        pq.pop();
    }

    return 0;
}

Answer 1

该网站还说：

根据这种严格的弱排序
，弹出的元素是最后一个

因此，元素以弱排序的相反顺序弹出。这是因为priority_queue实现了最大堆，即首先弹出最大元素（由弱排序定义）的堆。

如果你想实现一个min-heap（将元素从最小值弹出到最大值），你需要让你的比较函数做相反的操作，即当{且仅当{{1}时返回true根据你的订单。

Answer 2

尝试更改Comparator：

class Comparator{
public:
    bool operator()(const Number& a,const Number& b){
        if (a.getX()<b.getX()){
            return true;
        } else {
            return false;
        }
    }
};

对于这样的事情：

struct Comparator { 
    bool operator()(Number const &a, Number const &b) { 
        return b.getX() < a.getX();
    }
};

至少对我来说，你的Number看起来也很可疑。我想我可能完全消除它，直接使用int。如果由于某种原因你坚持使用课程，我会考虑支持转换为int：

class Number {
    int x;
public:
    Number(int x) : x(x) {}
    operator int() const { return x; }
};

...将Comparator类简化为：

class Comparator { 
    bool operator()(Number const &a, Number const &b) { 
        return b < a;
    }
};

...但这相当于std::greater，所以你也可以直接使用它，这样你的集合定义就像这样：

priority_queue<Number,vector<Number>, greater<Number> > pq;

在priority_queue内部排序

2 个答案: