C++ 关于c++；使用比较器 类节点{ 公众： 字符； 整数频率； 节点*左，*右； }; 类比较类{ 公众： int运算符（）（节点*a，节点*b） { 返回a->frequency-b->frequency； } }; 优先级队列；

我想说：

（示例）

节点A：优先级20
节点B：优先级4
节点C：优先级6
节点D：优先权7

排序之后

节点A（队列的第一个）：优先级20

节点D（队列的第2个）：优先级7

节点C：优先权6

节点B：优先级4

这样，我想按降序排列优先级

---

但是错误->表达式：无效运算符您的比较器不正确。它必须返回布尔值。这应该起作用：

class Node {

public:
    char character;
    int frequency;
    Node *left, *right;

};

class ComparisonClass {

public:
    int operator()(Node *a, Node *b)
    {
        return a->frequency - b->frequency;
    }
};


class huffman {

public:
    priority_queue<Node*, vector<Node*>, ComparisonClass> queue;
    hash_map<char, string> *idc = new hash_map<char,string>();

/*  
    Node* huffmanCoding(int n) // incomplete code
    {
        for (int i = 0; i < n - 1; i++)
        {
            Node *z = new Node();
            z->right = queue.top();
            queue.pop();
            z->left = queue.top();
            queue.pop();
            z->frequency = z->right->frequency + z->left->frequency;
            queue.push(z);
        }

        return queue.top();
    }
*/          
};



int main()
{
    string str = "AAAAAAABBCCCDEEEEFFFFFFG";

    hash_map<char, int> dictionary;

    for (int i = 0; i < str.length(); i++)
    {
        char temp = str.at(i);

        if (dictionary.find(temp) != dictionary.end())
            dictionary.find(temp)->second++;

        else
            dictionary.insert(hash_map<char,int>::value_type(temp,1));
    }



    huffman *huf = new huffman();
    int number = 0;

    for (hash_map<char, int>::iterator iter = dictionary.begin();
        iter != dictionary.end(); ++iter)
    {
        Node *temp = new Node(); 

        temp->character = iter->first;
        temp->frequency = iter->second;


        huf->queue.push(temp); <- error point
        number++; 
    }

}

类比较类
{
公众：
布尔运算符（）（节点*a，节点*b）
{
返回a->frequencyfrequency；
}
};

请显示有错误的代码。我包括了我的全部代码并检查了错误点（huf->queue.push（temp）；）

class Node {

public:
    char character;
    int frequency;
    Node *left, *right;

};

class ComparisonClass {

public:
    int operator()(Node *a, Node *b)
    {
        return a->frequency - b->frequency;
    }
};


class huffman {

public:
    priority_queue<Node*, vector<Node*>, ComparisonClass> queue;
    hash_map<char, string> *idc = new hash_map<char,string>();

/*  
    Node* huffmanCoding(int n) // incomplete code
    {
        for (int i = 0; i < n - 1; i++)
        {
            Node *z = new Node();
            z->right = queue.top();
            queue.pop();
            z->left = queue.top();
            queue.pop();
            z->frequency = z->right->frequency + z->left->frequency;
            queue.push(z);
        }

        return queue.top();
    }
*/          
};



int main()
{
    string str = "AAAAAAABBCCCDEEEEFFFFFFG";

    hash_map<char, int> dictionary;

    for (int i = 0; i < str.length(); i++)
    {
        char temp = str.at(i);

        if (dictionary.find(temp) != dictionary.end())
            dictionary.find(temp)->second++;

        else
            dictionary.insert(hash_map<char,int>::value_type(temp,1));
    }



    huffman *huf = new huffman();
    int number = 0;

    for (hash_map<char, int>::iterator iter = dictionary.begin();
        iter != dictionary.end(); ++iter)
    {
        Node *temp = new Node(); 

        temp->character = iter->first;
        temp->frequency = iter->second;


        huf->queue.push(temp); <- error point
        number++; 
    }

}

class ComparisonClass
{
public:
    bool operator()(Node *a, Node *b)
    {
        return a->frequency < b->frequency;
    }
};