C++ 使用struct和map创建优先级队列

我有一个结构：

struct Node {
    unsigned char symbol;
    unsigned int freq;
    Node* left;
    Node* right;

    Node(unsigned char _byte, int _freq)
        : symbol(_byte), freq(_freq), left(nullptr), right(nullptr) {};
};

并且已经创建了这样的无序地图：

std::unordered_map<unsigned char, uint> freqs ={{'a',12}, {'b',122}};

但这不起作用：

typedef

构造中出现错误：

函数“nodeCompare”不是类型名

附加问题： 如果我以这种方式创建向量，也许有某种方法可以在不创建额外向量的情况下将节点推送到我的_队列中

my_queue q;
std::vector<Node*> node_vect;
std::unordered_map<byte, uint>::iterator it;
for (it = freqs.begin(); it != freqs.end(); ++it)
{
    Node* new_node = new Node(it->first, it->second);
    node_vect.push_back(new_node);
    //q.push(new_node); this doesn't work
}

myu队列q；
std:：vector node\u vect；
std:：无序的_映射：：对其进行迭代器；
for（it=freqs.begin（）；it！=freqs.end（）；+it）
{
Node*new_Node=新节点（it->first，it->second）；
节点向量推回（新节点）；
//q、 推送（新节点）；这不起作用
}

优先级\u队列模板参数不需要函数，而是对象类型

template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

模板类优先级队列；

因此，只要将该函数包装成一个结构/类（Functor）就可以了

struct Comparator
{
  bool operator()(const Node* first, const Node* second) const {
    return first->freq > second->freq;
  }
};

typedef std::priority_queue<Node*,
                            std::vector<Node*>,
                            Comparator> my_queue;

结构比较器 { 布尔运算符（）（常数节点*第一个，常数节点*第二个）常数{ 返回第一->频率>第二->频率； } }; typedef std:：priority_queue my_queue； 如果您希望比较器位于节点结构内部，只需创建一个内部结构

struct Node {
    unsigned char symbol;
    unsigned int freq;
    Node* left;
    Node* right;

    Node(unsigned char _byte, int _freq)
        : symbol(_byte), freq(_freq), left(nullptr), right(nullptr) {};

    struct Comparator
    {
      bool operator()(const Node* first, const Node* second) const {
        return first->freq > second->freq;
      }
    };
};

typedef std::priority_queue<Node*,
                            std::vector<Node*>,
                            Node::Comparator> my_queue;

my_queue queue(node_vect.begin(), node_vect.end());

struct节点{
无符号字符符号；
无符号整数频率；
节点*左；
节点*右；
节点（无符号字符字节，整数频率）
：符号（_字节）、频率（_频率）、左（空ptr）、右（空ptr）{}；
结构比较器
{
布尔运算符（）（常数节点*第一个，常数节点*第二个）常数{
返回第一->频率>第二->频率；
}
};
};
typedef std:：priority_queue my_queue；
我的队列队列（node_vect.begin（），node_vect.end（））；

优先级\u队列模板参数不需要函数，而是对象类型

template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

模板类优先级队列；

因此，只要将该函数包装成一个结构/类（Functor）就可以了

struct Comparator
{
  bool operator()(const Node* first, const Node* second) const {
    return first->freq > second->freq;
  }
};

typedef std::priority_queue<Node*,
                            std::vector<Node*>,
                            Comparator> my_queue;

结构比较器 { 布尔运算符（）（常数节点*第一个，常数节点*第二个）常数{ 返回第一->频率>第二->频率； } }; typedef std:：priority_queue my_queue； 如果您希望比较器位于节点结构内部，只需创建一个内部结构

struct Node {
    unsigned char symbol;
    unsigned int freq;
    Node* left;
    Node* right;

    Node(unsigned char _byte, int _freq)
        : symbol(_byte), freq(_freq), left(nullptr), right(nullptr) {};

    struct Comparator
    {
      bool operator()(const Node* first, const Node* second) const {
        return first->freq > second->freq;
      }
    };
};

typedef std::priority_queue<Node*,
                            std::vector<Node*>,
                            Node::Comparator> my_queue;

my_queue queue(node_vect.begin(), node_vect.end());

struct节点{
无符号字符符号；
无符号整数频率；
节点*左；
节点*右；
节点（无符号字符字节，整数频率）
：符号（_字节）、频率（_频率）、左（空ptr）、右（空ptr）{}；
结构比较器
{
布尔运算符（）（常数节点*第一个，常数节点*第二个）常数{
返回第一->频率>第二->频率；
}
};
};
typedef std:：priority_queue my_queue；
我的队列队列（node_vect.begin（），node_vect.end（））；

我可以将

比较器

添加到我的

节点

结构中吗？在typedef中使用它？或者我需要创建一个新的？是的，没有问题，你能展示一下这个例子吗？我不知道如何添加-尝试了结构方法，但仍然不起作用：（太棒了！它起作用了！我已经投票给了你的答案！但我还有一个问题-我不知道在这里再问一次是否可以…请看我对问题的添加。哦，看起来这是输入错误：）我可以将

比较器添加到
节点
结构中吗？在typedef中使用它？或者我需要创建一个新的？是的，没有问题，你能展示一下这个例子吗？我不知道如何添加-尝试了struct方法，但仍然不起作用：（太棒了！它起作用了！我已经投了你的票！但我还有一个问题-不知道在这里再问一次是否可以…请看我添加到问题中的内容。哦，看起来这是打字错误：）