C++项目 - 文件压缩

文件压缩

---

开发环境：Windows Visual Studio 2013

项目概述：利用Huffman编码可对任意文件（包含图片、视频、音频）进行压缩和解压缩。

使用技术：运用到的数据结构：Heap堆、Huffmantree哈夫曼树、Huffmancode哈夫曼编码

项目思想：压缩文件时利用小堆建立哈夫曼树，依据建立的哈夫曼树产生哈夫曼编码。利用哈夫曼编码对文件进行压缩，产生压缩文件和配置文件。

---

那么何为哈夫曼数？

• Huffman树，又称为最优二叉树，是加权路径长度最短的二叉树。

【贪心算法】

• 是指在问题求解时，总是做出当前看起来最好的选择。也就是说贪心算法做出的不是整体最优的的选择，而是某种意义上的 局部最优解。贪心算法不是对所有的问题都能得到整体最优解。

使用贪心算法构建Huffman树：

---

利用哈夫曼树生成哈夫曼编码，

• 源代码如下：
  huffmantree.h

#pragma once  

#include "heap.h"  
#include<assert.h>  


template<class T>
struct HuffmanTreeNode
{
    HuffmanTreeNode<T>* _left;
    HuffmanTreeNode<T>* _right;
    HuffmanTreeNode<T>* _parent;
    T _weight;

    HuffmanTreeNode(const T& x)
        :_weight(x)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
    {}
};

template<class T>
class HuffmanTree
{
    typedef HuffmanTreeNode<T> Node;

public:

    HuffmanTree()
        :_root(NULL)
    {}

    ~HuffmanTree()
    {
        Destory(_root);
    }

    template <class T>
    struct NodeCompare
    {
        bool operator()(Node *l, Node *r)
        {
            return l->_weight < r->_weight;
        }
    };

public:
    void CreatTree(const T* a, size_t size, const T& invalid)
    {
        assert(a);
        Heap<Node*, NodeCompare<T>> minHeap;
        for (size_t i = 0; i < size; ++i)
        {
            if (a[i] != invalid)
            {
                Node* node = new Node(a[i]);
                minHeap.Push(node);
            }
        }

        while (minHeap.Size() > 1)
        {
            Node* left = minHeap.Top();
            minHeap.Pop();
            Node* right = minHeap.Top();
            minHeap.Pop();

            Node* parent = new Node(left->_weight + right->_weight);
            parent->_left = left;
            parent->_right = right;
            left->_parent = parent;
            right->_parent = parent;

            minHeap.Push(parent);
        }

        _root = minHeap.Top();
    }

    Node* GetRootNode()
    {
        return _root;
    }

    void Destory(Node* root)
    {
        if (root)
        {
            D