哈夫曼树的编码和译码c++

哈夫曼树是一种用于数据压缩的算法，主要用于实现有效的编码和译码。它的编码和译码过程如下：

编码：
1. 统计待编码数据中各个字符出现的频次。
2. 根据频次构建哈夫曼树。频次越高的字符离根节点越近，频次越低的字符离根节点越远。
3. 通过遍历哈夫曼树，为每个字符建立唯一的编码。从根节点开始，沿着左子树路径走为0，沿着右子树路径走为1，直到找到叶子节点。将经过的路径编码记录下来。
4. 将编码后的结果存储起来，以便后续译码使用。

译码：
1. 根据编码后的数据和对应的哈夫曼树，从根节点开始逐位读取编码。
2. 如果读取到的位为0，则沿着左子树路径继续向下读取。如果读取到的位为1，则沿着右子树路径继续向下读取。
3. 当读取到叶子节点时，将叶子节点对应的字符输出，并回到哈夫曼树的根节点，继续读取下一位编码。
4. 重复上述步骤，直到读取完所有编码。

哈夫曼树的编码和译码过程是互逆的，编码可以通过哈夫曼树实现数据的压缩，译码则可以根据编码和哈夫曼树恢复原始数据。它的主要优点是根据字符频次构建哈夫曼树，使得频率高的字符用较短的编码表示，而频率低的字符用较长的编码表示，从而实现了数据的高效压缩和解压缩。

相关问题

哈夫曼编码和译码C++

以下是C++实现哈夫曼编码和译码的示例代码：

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

// 哈夫曼树节点
struct HuffmanNode {
    char ch; // 字符
    int freq; // 频率
    HuffmanNode* left; // 左子节点
    HuffmanNode* right; // 右子节点
    HuffmanNode(char c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {}
};

// 哈夫曼树节点比较器
struct Compare {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {
        return a->freq > b->freq;
    }
};

// 构建哈夫曼树
HuffmanNode* buildHuffmanTree(const string& str) {
    // 统计字符频率
    unordered_map<char, int> freqMap;
    for (char c : str) {
        freqMap[c]++;
    }

    // 构建哈夫曼树
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> pq;
    for (auto& p : freqMap) {
        pq.push(new HuffmanNode(p.first, p.second));
    }
    while (pq.size() > 1) {
        HuffmanNode* left = pq.top();
        pq.pop();
        HuffmanNode* right = pq.top();
        pq.pop();
        HuffmanNode* parent = new HuffmanNode('*', left->freq + right->freq);
        parent->left = left;
        parent->right = right;
        pq.push(parent);
    }
    return pq.top();
}

// 生成哈夫曼编码
void generateHuffmanCode(HuffmanNode* root, string code, unordered_map<char, string>& codeMap) {
    if (!root) {
        return;
    }
    if (!root->left && !root->right) {
        codeMap[root->ch] = code;
    }
    generateHuffmanCode(root->left, code + "0", codeMap);
    generateHuffmanCode(root->right, code + "1", codeMap);
}

// 哈夫曼编码
string huffmanEncode(const string& str) {
    // 构建哈夫曼树
    HuffmanNode* root = buildHuffmanTree(str);

    // 生成哈夫曼编码
    unordered_map<char, string> codeMap;
    generateHuffmanCode(root, "", codeMap);

    // 编码
    string encodedStr;
    for (char c : str) {
        encodedStr += codeMap[c];
    }
    return encodedStr;
}

// 哈夫曼译码
string huffmanDecode(const string& str, HuffmanNode* root) {
    string decodedStr;
    HuffmanNode* cur = root;
    for (char c : str) {
        if (c == '0') {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
        if (!cur->left && !cur->right) {
            decodedStr += cur->ch;
            cur = root;
        }
    }
    return decodedStr;
}

int main() {
    string str = "abaccdaA";
    string encodedStr = huffmanEncode(str);
    cout << "Encoded string: " << encodedStr << endl;

    HuffmanNode* root = buildHuffmanTree(str);
    string decodedStr = huffmanDecode(encodedStr, root);
    cout << "Decoded string: " << decodedStr << endl;

    return 0;
}

哈夫曼树编码译码代码cpp

以下是哈夫曼树编码译码的C++代码示例：

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

// 哈夫曼树节点
struct HuffmanNode {
    char ch;
    int freq;
    HuffmanNode *left, *right;

    HuffmanNode(char c, int f) {
        ch = c;
        freq = f;
        left = right = nullptr;
    }

    ~HuffmanNode() {
        delete left;
        delete right;
    }
};

// 比较函数
struct Compare {
    bool operator()(const HuffmanNode* a, const HuffmanNode* b) const {
        return a->freq > b->freq;
    }
};

// 构建哈夫曼树
HuffmanNode* buildHuffmanTree(map<char, int> freqMap) {
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> pq;
    for (auto& p : freqMap) {
        pq.push(new HuffmanNode(p.first, p.second));
    }

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

// 构建编码表
void buildCodeTable(HuffmanNode* root, string code, map<char, string>& codeTable) {
    if (root == nullptr) {
        return;
    }
    if (root->ch != '$') {
        codeTable[root->ch] = code;
    }
    buildCodeTable(root->left, code + "0", codeTable);
    buildCodeTable(root->right, code + "1", codeTable);
}

// 编码字符串
string encodeString(string str, map<char, string> codeTable) {
    string encodedString = "";
    for (char c : str) {
        encodedString += codeTable[c];
    }
    return encodedString;
}

// 译码字符串
string decodeString(string str, HuffmanNode* root) {
    string decodedString = "";
    HuffmanNode* cur = root;
    for (char c : str) {
        if (c == '0') {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
        if (cur->ch != '$') {
            decodedString += cur->ch;
            cur = root;
        }
    }
    return decodedString;
}

int main() {
    // 统计频率
    string str = "hello, world!";
    map<char, int> freqMap;
    for (char c : str) {
        freqMap[c]++;
    }

    // 构建哈夫曼树
    HuffmanNode* root = buildHuffmanTree(freqMap);

    // 构建编码表
    map<char, string> codeTable;
    buildCodeTable(root, "", codeTable);

    // 编码字符串
    string encodedString = encodeString(str, codeTable);
    cout << "Encoded string: " << encodedString << endl;

    // 译码字符串
    string decodedString = decodeString(encodedString, root);
    cout << "Decoded string: " << decodedString << endl;

    // 释放资源
    delete root;

    return 0;
}

该程序的输入为一个字符串，输出为该字符串的哈夫曼编码和译码结果。程序首先统计输入字符串中每个字符出现的频率，并利用此信息构建哈夫曼树。然后，程序根据哈夫曼树构建编码表，用于将输入字符串编码为哈夫曼编码。最后，程序将哈夫曼编码译码为原始字符串。