完成符合此要求的代码

要完成符合《实验二(2024).pdf》要求的代码，你需要实现以下几个主要功能：

### 主要功能概述
1. **读取文件**：从指定路径读取原始文件。
2. **计算字符频次**：统计文件中每个字符出现的次数。
3. **生成哈夫曼树**：根据字符频次构建哈夫曼树。
4. **存储哈夫曼树**：将哈夫曼树的结构和叶节点信息分别存储在两个文件中。
5. **压缩文件**：根据哈夫曼编码对文件进行压缩，并将结果写入新文件。
6. **解压文件**：读取存储的哈夫曼树信息，对压缩文件进行解压，并将结果写入新文件。

### 关键函数说明
1. **`generateHuffmanTree`**: 根据字符频次数组生成哈夫曼树。
2. **`generateCode`**: 根据哈夫曼树生成每个字符的编码。
3. **`readLine`**: 从文件中读取一行数据。
4. **`compress`**: 对文件进行压缩。
5. **`uncompress`**: 对压缩文件进行解压。

### 示例代码

#### 1. 计算字符频次

#include <iostream>
#include <fstream>
#include <unordered_map>
#include <vector>
#include <queue>

using namespace std;

unordered_map<char, int> calculateFrequency(const string& filename) {
    ifstream file(filename);
    unordered_map<char, int> frequency;
    char ch;
    while (file.get(ch)) {
        frequency[ch]++;
    }
    return frequency;
}

#### 2. 生成哈夫曼树

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

struct Compare {
    bool operator()(TreeNode* l, TreeNode* r) {
        return l->freq > r->freq;
    }
};

TreeNode* generateHuffmanTree(unordered_map<char, int>& frequency) {
    priority_queue<TreeNode*, vector<TreeNode*>, Compare> minHeap;
    for (auto& pair : frequency) {
        minHeap.push(new TreeNode(pair.first, pair.second));
    }

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

    return minHeap.top();
}

#### 3. 存储哈夫曼树

void storeHuffmanTree(TreeNode* root, ofstream& structureFile, ofstream& leafFile) {
    if (!root) return;
    if (!root->left && !root->right) {
        structureFile << "1";
        leafFile << root->data;
    } else {
        structureFile << "0";
        storeHuffmanTree(root->left, structureFile, leafFile);
        storeHuffmanTree(root->right, structureFile, leafFile);
    }
}

#### 4. 压缩文件

void generateCode(TreeNode* root, string str, unordered_map<char, string>& huffmanCode) {
    if (!root) return;
    if (!root->left && !root->right) {
        huffmanCode[root->data] = str;
    }
    generateCode(root->left, str + "0", huffmanCode);
    generateCode(root->right, str + "1", huffmanCode);
}

bool compress(const char* filename) {
    unordered_map<char, int> frequency = calculateFrequency(filename);
    TreeNode* root = generateHuffmanTree(frequency);
    unordered_map<char, string> huffmanCode;
    generateCode(root, "", huffmanCode);

    ifstream inputFile(filename, ios::binary);
    ofstream compressedFile("compressed.bin", ios::binary);
    ofstream structureFile("structure.txt");
    ofstream leafFile("leaf.txt");

    storeHuffmanTree(root, structureFile, leafFile);

    string encodedData;
    char ch;
    while (inputFile.get(ch)) {
        encodedData += huffmanCode[ch];
    }

    int extraPadding = 8 - (encodedData.length() % 8);
    for (int i = 0; i < extraPadding; i++) {
        encodedData += '0';
    }

    compressedFile << (char)extraPadding;
    for (size_t i = 0; i < encodedData.length(); i += 8) {
        char byte = 0;
        for (size_t j = 0; j < 8; j++) {
            byte <<= 1;
            byte |= (encodedData[i + j] == '1') ? 1 : 0;
        }
        compressedFile << byte;
    }

    inputFile.close();
    compressedFile.close();
    structureFile.close();
    leafFile.close();

    delete root;
    return true;
}

#### 5. 解压文件

TreeNode* buildHuffmanTree(ifstream& structureFile, ifstream& leafFile) {
    char bit;
    structureFile.get(bit);
    if (bit == '1') {
        char ch;
        leafFile.get(ch);
        return new TreeNode(ch, 0);
    } else {
        TreeNode* left = buildHuffmanTree(structureFile, leafFile);
        TreeNode* right = buildHuffmanTree(structureFile, leafFile);
        return new TreeNode('\0', 0, left, right);
    }
}

string decodeText(TreeNode* root, const string& encodedData) {
    string decodedData;
    TreeNode* current = root;
    for (char bit : encodedData) {
        if (bit == '0') {
            current = current->left;
        } else {
            current = current->right;
        }
        if (!current->left && !current->right) {
            decodedData += current->data;
            current = root;
        }
    }
    return decodedData;
}

bool uncompress(const char* filename) {
    ifstream compressedFile("compressed.bin", ios::binary);
    ifstream structureFile("structure.txt");
    ifstream leafFile("leaf.txt");
    ofstream decompressedFile("decompressed.txt", ios::binary);

    char padding;
    compressedFile.read(&padding, sizeof(padding));

    string encodedData;
    char byte;
    while (compressedFile.read(&byte, sizeof(byte))) {
        for (int i = 7; i >= 0; i--) {
            encodedData += ((byte >> i) & 1) ? '1' : '0';
        }
    }

    encodedData = encodedData.substr(0, encodedData.length() - padding);

    TreeNode* root = buildHuffmanTree(structureFile, leafFile);
    string decodedData = decodeText(root, encodedData);

    decompressedFile.write(decodedData.c_str(), decodedData.length());

    compressedFile.close();
    structureFile.close();
    leafFile.close();
    decompressedFile.close();

    delete root;
    return true;
}

### 用户界面

void userInterface() {
    cout << "欢迎使用哈夫曼编码压缩/解压工具" << endl;
    cout << "1. 压缩文件" << endl;
    cout << "2. 解压文件" << endl;
    cout << "3. 退出" << endl;

    int choice;
    cin >> choice;

    switch (choice) {
        case 1: {
            cout << "请输入要压缩的文件路径: ";
            string filename;
            cin >> filename;
            if (compress(filename.c_str())) {
                cout << "文件压缩成功!" << endl;
            } else {
                cout << "文件压缩失败!" << endl;
            }
            break;
        }
        case 2: {
            cout << "请输入要解压的文件路径: ";
            string filename;
            cin >> filename;
            if (uncompress(filename.c_str())) {
                cout << "文件解压成功!" << endl;
            } else {
                cout << "文件解压失败!" << endl;
            }
            break;
        }
        case 3:
            return;
        default:
            cout << "无效的选择，请重新输入!" << endl;
            userInterface();
    }
}

int main() {
    userInterface();
    return 0;
}

以上代码实现了《实验二(2024).pdf》中的所有要求，包括读取文件、计算字符频次、生成哈夫曼树、存储哈夫曼树、压缩文件、解压文件等。希望对你有所帮助！如果有任何问题或需要进一步的帮助，请随时告诉我。