Question

这是我第一次使用优先级队列。我正在尝试为学校实现Dijkstra的算法，我想我需要一个最小堆才能做到这一点。现在我的节点是指针，我想比较它们的重量，但我认为我不能超载＆gt;和＆lt;用指针？有没有办法可以做到这一点？

远远地编码：

priority_queue<Node*, vector<Node*>, node_comparison> minHeap;

然后我有一个结构来比较节点的权重

struct node_comparison 
{
   bool operator<( const Node* a, const Node* b ) const 
   {
    return a->totalWeight < b->totalWeight;
   }
};

然而，它表示此操作员功能的参数太多。我一直试图找出如何用我的节点管理一个最小堆优先级队列一段时间，然后继续卡住。有什么想法吗？

Answer 1

如果我理解你的问题，我相信你真正想要的是让node_comparison成为仿函数（更具体地说，是一个二元谓词）：

struct node_comparison 
{
    bool operator () ( const Node* a, const Node* b ) const 
    {
        return a->totalWeight < b->totalWeight;
    }
};

仿函数是一个类，其对象提供了调用操作符（operator ()）的重载，因此可以使用与调用函数相同的语法调用：

Node* p1 = ...;
Node* p2 = ...;
node_comparison comp;
bool res = comp(p1, p2) // <== Invokes your overload of operator ()

在内部，std::priority_queue或多或少会像上面的代码片段中那样实例化你的谓词，并以这种方式调用它来执行其元素之间的比较。

仿函数相对于常规函数的优势在于它们可以保存状态信息（您可能目前不需要的东西，但通常证明是理想的）：

#include <cmath>

struct my_comparator
{
    my_comparator(int x) : _x(x) { }

    bool operator () (int n, int m) const
    {
        return abs(n - _x) < abs(m - _x);
    }

    int _x;
};

例如，上述谓词根据整数与构造时提供的另一个整数的距离来比较整数。这是如何使用的：

#include <queue>
#include <iostream>

void foo(int pivot)
{
    my_comparator mc(pivot);
    std::priority_queue<int, std::deque<int>, my_comparator> pq(mc);

    pq.push(9);
    pq.push(2);
    pq.push(17);

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

int main()
{
    foo(7);

    std::cout << std::endl;

    foo(10);
}

Answer 2

您需要使用比较函数来实现bool operator()(....)，而不是bool operator<(....)：

struct node_comparison 
{
   bool operator()( const Node* a, const Node* b ) const 
   {
    return a->totalWeight < b->totalWeight;
   }
};

STL优先级队列和带指针的重载

2 个答案: