基于哈夫曼的文件压缩

首先构建Huffman树，定义节点，以及初始化HuffmanTree的创建过程。

#pragma once
#include <iostream>
#include <queue>


template<class T>
struct HuffmantreeNode
{
    HuffmantreeNode* left;
    HuffmantreeNode* right;
    HuffmantreeNode* parent;
    T date;

    HuffmantreeNode(const T& val = T())
        :left(nullptr)
        , right(nullptr)
        , parent(nullptr)
        ,date(val) 
    {}
};



template<class T>
class Huffmantree
{
    typedef HuffmantreeNode<T> Node;

    struct Compare
    {
        bool operator()(const Node* x, const Node* y)
        {
            return x->date > y->date;
        }
    };
    
public:
    Huffmantree()
        :root(nullptr)
    {}

    Huffmantree(const std::vector<T>& vw,const T& invalid) 
    {
        std::priority_queue<Node* , std::vector<Node*>,Compare> q;
        //1.使用权值来构建二叉树
        for (auto& e : vw)
        {
            if(invalid!=e)
                q.push(new Node(e));
        }

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

            Node* parent = new Node(left->date + right->date);
            parent->left = left;
            parent->right = right;
            q.push(parent);
        }
        root = q.top();
    }
    Node* getroot()
    {
        return root;
    }

    ~Huffmantree()
    {
        Destroy(root);
    }
private:
    void Destroy(Node*& root)
    {
        if (root)
        {
            Destroy(root->left);
            Destroy(root->right);
            delete root;
            root = nullptr;
        }
    }
    Node* root;
};

紧接着通过文件来获取字符信息，因此需要定义一个类用来存储文件当中的字符信息，且构建byteinfo类来方便fileinfo存储文件信息，使得可以通过该信息构建Huffman树进行解压缩