C++怎么进行数据压缩 C++数据压缩的常用算法与实现

#include <iostream>
#include <queue>
#include <map>

struct Node {
    char ch;
    int freq;
    Node *left, *right;

    Node(char ch, int freq) : ch(ch), freq(freq), left(nullptr), right(nullptr) {}
};

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

std::map<char, std::string> generateHuffmanCodes(std::map<char, int> freq) {
    std::priority_queue<Node*, std::vector<Node*>, Compare> pq;

    for (auto pair : freq) {
        pq.push(new Node(pair.first, pair.second));
    }

    while (pq.size() > 1) {
        Node *left = pq.top();
        pq.pop();

        Node *right = pq.top();
        pq.pop();

        Node *newNode = new Node('$', left->freq + right->freq);
        newNode->left = left;
        newNode->right = right;

        pq.push(newNode);
    }

    Node* root = pq.top();

    std::map<char, std::string> huffmanCodes;
    std::function<void(Node*, std::string)> traverseTree = 
        [&](Node* node, std::string code) {
        if (!node) return;

        if (node->ch != '$') {
            huffmanCodes[node->ch] = code;
        }

        traverseTree(node->left, code + "0");
        traverseTree(node->right, code + "1");
    };

    traverseTree(root, "");
    return huffmanCodes;
}

int main() {
    std::string text = "this is an example of huffman encoding";
    std::map<char, int> freq;
    for (char ch : text) {
        freq[ch]++;
    }

    std::map<char, std::string> huffmanCodes = generateHuffmanCodes(freq);

    std::cout << "Huffman Codes:\n";
    for (auto pair : huffmanCodes) {
        std::cout << pair.first << " : " << pair.second << std::endl;
    }

    return 0;
}

#include <iostream>
#include <fstream>
#include <vector>
#include <zlib.h>

int main() {
    std::ifstream inputFile("input.txt", std::ios::binary);
    std::ofstream outputFile("output.zlib", std::ios::binary);

    if (!inputFile.is_open() || !outputFile.is_open()) {
        std::cerr << "Error opening files!" << std::endl;
        return 1;
    }

    std::vector<char> inputData((std::istreambuf_iterator<char>(inputFile)),
                                 (std::istreambuf_iterator<char>()));
    inputFile.close();

    z_stream zs;
    memset(&zs, 0, sizeof(zs));

    if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
        std::cerr << "deflateInit failed!" << std::endl;
        return 1;
    }

    zs.next_in = (Bytef*)inputData.data();
    zs.avail_in = inputData.size();

    int ret;
    char outbuffer[4096];
    std::vector<char> compressedData;

    do {
        zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
        zs.avail_out = sizeof(outbuffer);

        ret = deflate(&zs, Z_FINISH);

        if (ret == Z_STREAM_ERROR) {
            std::cerr << "deflate failed!" << std::endl;
            deflateEnd(&zs);
            return 1;
        }

        int have = sizeof(outbuffer) - zs.avail_out;
        compressedData.insert(compressedData.end(), outbuffer, outbuffer + have);

    } while (zs.avail_out == 0);

    deflateEnd(&zs);

    outputFile.write(compressedData.data(), compressedData.size());
    outputFile.close();

    std::cout << "File compressed successfully!" << std::endl;

    return 0;
}

#include <iostream>
#include <fstream>
#include <chrono>
#include <vector>
#include <zlib.h>

int main() {
    std::ifstream inputFile("large_input_file.txt", std::ios::binary);
    std::vector<char> inputData((std::istreambuf_iterator<char>(inputFile)),
                                 (std::istreambuf_iterator<char>()));
    inputFile.close();

    // 压缩
    z_stream zs;
    memset(&zs, 0, sizeof(zs));
    deflateInit(&zs, Z_DEFAULT_COMPRESSION);
    zs.next_in = (Bytef*)inputData.data();
    zs.avail_in = inputData.size();

    char outbuffer[4096];
    std::vector<char> compressedData;

    auto start = std::chrono::high_resolution_clock::now();
    do {
        zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
        zs.avail_out = sizeof(outbuffer);
        deflate(&zs, Z_FINISH);
        int have = sizeof(outbuffer) - zs.avail_out;
        compressedData.insert(compressedData.end(), outbuffer, outbuffer + have);
    } while (zs.avail_out == 0);
    auto end = std::chrono::high_resolution_clock::now();

    deflateEnd(&zs);

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Compression Time: " << duration.count() << " ms" << std::endl;

    // 解压缩 (简略，仅用于演示)
    // ... (解压缩代码) ...

    double compressionRatio = (double)compressedData.size() / inputData.size();
    std::cout << "Compression Ratio: " << compressionRatio << std::endl;

    return 0;
}