c++实现哈夫曼树建树

可以使用贪心算法实现哈夫曼树建树。具体步骤如下：

1. 将所有权值存储在一个数组中，并将数组按照权值从小到大排序。

2. 取出权值最小的两个元素，建立一个新节点，将这两个元素作为新节点的左右子节点，并将新节点的权值设为这两个元素权值之和。

3. 将新节点插入到数组中，并将原来的两个元素从数组中删除。

4. 重复2、3步骤，直到数组中只剩下一个节点，该节点即为哈夫曼树的根节点。

需要注意的是，在插入新节点时，需要按照权值从小到大的顺序插入，并且如果有多个节点具有相同的权值，应该按照它们在数组中的顺序插入。这样可以保证建立的哈夫曼树是唯一的。

相关问题

用c++实现哈夫曼树

以下是用C++实现哈夫曼树的代码示例：

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

// 定义哈夫曼树结点
struct HuffmanNode {
    int weight; // 权重
    char ch; // 字符
    HuffmanNode *left, *right; // 左右子树指针
    HuffmanNode(int w, char c) : weight(w), ch(c), left(nullptr), right(nullptr) {}
};

// 定义比较函数，用于优先队列
struct cmp {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {
        return a->weight > b->weight;
    }
};

// 构造哈夫曼树
HuffmanNode* buildHuffmanTree(vector<int>& weights, vector<char>& chars) {
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, cmp> pq;
    for (int i = 0; i < weights.size(); i++) {
        pq.push(new HuffmanNode(weights[i], chars[i]));
    }
    while (pq.size() > 1) {
        HuffmanNode* left = pq.top();
        pq.pop();
        HuffmanNode* right = pq.top();
        pq.pop();
        HuffmanNode* parent = new HuffmanNode(left->weight + right->weight, '\0');
        parent->left = left;
        parent->right = right;
        pq.push(parent);
    }
    return pq.top();
}

// 遍历哈夫曼树，生成哈夫曼编码
void generateHuffmanCode(HuffmanNode* root, string code, vector<string>& codes) {
    if (!root) {
        return;
    }
    if (root->ch != '\0') {
        codes[root->ch] = code;
    }
    generateHuffmanCode(root->left, code + "0", codes);
    generateHuffmanCode(root->right, code + "1", codes);
}

// 主函数
int main() {
    vector<int> weights = {5, 9, 12, 13, 16, 45};
    vector<char> chars = {'a', 'b', 'c', 'd', 'e', 'f'};
    HuffmanNode* root = buildHuffmanTree(weights, chars);
    vector<string> codes(128);
    generateHuffmanCode(root, "", codes);
    for (int i = 0; i < 128; i++) {
        if (!codes[i].empty()) {
            cout << (char)i << ": " << codes[i] << endl;
        }
    }
    return 0;
}

c++实现哈夫曼树的编码与解码

哈夫曼树是一种常用的数据结构，可以用于数据的压缩和解压缩。下面是C++实现的哈夫曼树编码和解码的示例代码：

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

struct TreeNode {
    char ch;
    int freq;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {}
};

struct Compare {
    bool operator() (const TreeNode* a, const TreeNode* b) {
        return a->freq > b->freq;
    }
};

void buildHuffmanTree(string str, unordered_map<char, int>& freqMap, priority_queue<TreeNode*, vector<TreeNode*>, Compare>& minHeap) {
    for (char c : str) {
        if (freqMap.find(c) == freqMap.end()) {
            freqMap[c] = 1;
        } else {
            freqMap[c]++;
        }
    }

    for (auto& entry : freqMap) {
        TreeNode* node = new TreeNode(entry.first, entry.second);
        minHeap.push(node);
    }

    while (minHeap.size() > 1) {
        TreeNode* left = minHeap.top(); minHeap.pop();
        TreeNode* right = minHeap.top(); minHeap.pop();
        TreeNode* parent = new TreeNode('$', left->freq + right->freq);
        parent->left = left;
        parent->right = right;
        minHeap.push(parent);
    }
}

void encode(TreeNode* node, string code, unordered_map<char, string>& codeMap) {
    if (node == nullptr) return;
    if (node->left == nullptr && node->right == nullptr) {
        codeMap[node->ch] = code;
        return;
    }
    encode(node->left, code + "0", codeMap);
    encode(node->right, code + "1", codeMap);
}

void huffmanEncode(string str, unordered_map<char, string>& codeMap) {
    unordered_map<char, int> freqMap;
    priority_queue<TreeNode*, vector<TreeNode*>, Compare> minHeap;
    buildHuffmanTree(str, freqMap, minHeap);
    TreeNode* root = minHeap.top();
    encode(root, "", codeMap);
}

void huffmanDecode(TreeNode* root, string code, string& result) {
    if (root == nullptr) return;
    TreeNode* curr = root;
    for (char c : code) {
        if (c == '0') {
            curr = curr->left;
        } else {
            curr = curr->right;
        }
        if (curr->left == nullptr && curr->right == nullptr) {
            result += curr->ch;
            curr = root;
        }
    }
}

int main() {
    string str = "hello world";
    unordered_map<char, string> codeMap;
    huffmanEncode(str, codeMap);

    string encoded = "";
    for (char c : str) {
        encoded += codeMap[c];
    }

    cout << "Encoded string: " << encoded << endl;

    string decoded = "";
    TreeNode* root = new TreeNode('$', 0);
    for (auto& entry : codeMap) {
        string code = entry.second;
        char ch = entry.first;
        TreeNode* curr = root;
        for (char c : code) {
            if (c == '0') {
                if (curr->left == nullptr) {
                    curr->left = new TreeNode('$', 0);
                }
                curr = curr->left;
            } else {
                if (curr->right == nullptr) {
                    curr->right = new TreeNode('$', 0);
                }
                curr = curr->right;
            }
        }
        curr->ch = ch;
    }
    huffmanDecode(root, encoded, decoded);

    cout << "Decoded string: " << decoded << endl;

    return 0;
}

以上代码实现了哈夫曼树的编码和解码，其中`buildHuffmanTree`函数用于构建哈夫曼树，`encode`函数用于将哈夫曼树转换为编码表，`huffmanEncode`函数用于对字符串进行编码，`huffmanDecode`函数用于对编码后的字符串进行解码。