Huffman树---之文件压缩项目

最新推荐文章于 2020-05-25 01:51:45 发布
最新推荐文章于 2020-05-25 01:51:45 发布
阅读量347 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 压缩 heap 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angry_youth/article/details/76208924
版权

HuffmanTree哈夫曼树：

又称最优二叉树，是加权路径长度最短的二叉树；
如何建树，思想如下：

这里写图片描述

以此类推最终将其构建成以下的样子：

这里写图片描述

代码如下：


#include"heap_review.h"//自己实现的堆模板类，见上篇堆文章
#include<queue>

template <class T>
struct HuffmanTreeNode
{
    T _data;
    HuffmanTreeNode<T>* _left;
    HuffmanTreeNode<T>* _right;
    HuffmanTreeNode(const T& data)
        :_data(data),_left(NULL),_right(NULL)
    {}
};

template <class T>
class HuffmanTree
{
    typedef HuffmanTreeNode<T> Node;
protected:
    Node* _root;
public:
    HuffmanTree()
        :_root(NULL)
    {}
    struct NodeCompare
    {
        bool operator()(const Node* left, const Node* right)
        {
            return left->_data < right->_data;
        }
    };
    HuffmanTree(T* arr,int n,T invalid)
    {
        //创建一个小堆
        Heap<Node*,NodeCompare> minHeap;
        for(int i = 0; i < n; i++)
        {
            if(arr[i] != invalid)
            {
                minHeap.Push(new Node(arr[i]));
            }
        }
        //创建Huffman树
        while(minHeap.Size() > 1)
        {
            //取出前两个最小的值
            Node* left = minHeap.Top();
            minHeap.Pop();
            Node* right = minHeap.Top();
            minHeap.Pop();
            //创建一个父节点，值为两个孩子之和
            Node* parent = new Node(left->_data + right->_data);
            parent->_left = left;
            parent->_right = right;
            minHeap.Push(parent);
        }
        _root = minHeap.Top();//将根节点赋给_root
    }

    void showHuffman()
    {
        cout<<"层序遍历哈弗曼树："<<endl;
        _showHuffman(_root);
        cout<<endl;
    }
    //层序遍历
    void _showHuffman(Node* root)
    {
        if(NULL == root)
            return;
        queue<Node*> q;
        q.push(root);
        while(!q.empty())
        {
            Node* cur = q.front();
            cout<<cur->_data<<" ";
            if(cur->_left != NULL)
            {
                q.push(cur->_left);
            }
            if(cur->_right != NULL)
            {
                q.push(cur->_right);
            }
            q.pop();
        }
    }
};


void TestHuffmanTree()
{
    int arr[] = {0,1,2,3,'*','*',4,5,6,7,8,9,'*'};
    size_t len = sizeof(arr)/sizeof(arr[0]);
    HuffmanTree<int> hf(arr,len,'*');
    hf.showHuffman();
}

然后将_root指针指向根节点45即可，这颗哈夫曼树就已经建好了，实现结果如下：
这里写图片描述

**Huffman树项目：
文件压缩步骤：**
1. 统计字符出现的次数；
2. 构建HuffmanTree哈夫曼树；
3. 生成Huffman编码；（自由定义，这里我们定义为左0，右1）
4. 压缩文件；

这里写图片描述


#include"HuffmanTree_review.h"

typedef long LongType;
struct charInfo
{
    char _ch;//字符
    LongType _count;//字符出现的次数
    string _code;//字符的huffman编码

    charInfo operator+(const charInfo& t)const
    {
        charInfo ret;
        ret._count = _count + t._count;
        return ret;
    }
    bool operator<(const charInfo& t)const
    {
        return this->_count < t._count;
    }

    bool operator!=(const charInfo& t)const
    {
        return this->_count != t._count;
    }
};
//压缩文件类
class FileCompress
{
    typedef HuffmanTreeNode<charInfo> Node;
protected:
    charInfo _infor[256];
public:
    FileCompress()
    {
        //初始化数组
        for(size_t i = 0; i < 256; ++i)
        {
            _infor[i]._ch = i;
            _infor[i]._count = 0;
        }
    }
    //统计字符出现的次数
    //创建Huffman树
    void CountCharCreateTree(const char* filename)
    {
        //统计所有字符出现的次数
        assert(filename);
        FILE* fd = fopen(filename,"r");
        if(NULL == fd)
        {
            perror("open file is error");
            return;
        }
        int ch = fgetc(fd);//**获取第一个字符,如果把ch设置成char那将无法压缩汉字，unsigned char也不行，这样会陷入死循环**
        while(ch != EOF)
        {
            _infor[ch]._count++;
            ch = fgetc(fd);
        }
        //构建Huffman树
        charInfo invalid;
        invalid._count = 0;//出现次数<=0的直接丢弃
        HuffmanTree<charInfo> heap(_infor,256,invalid);
        //生成Huffman编码
        string code;
        CreateHuffmanCodeR(heap.GetRoot(),code);

        //压缩
        //生成压缩文件，将压缩信息存储在压缩文件中
        string compressFile = filename;
        compressFile += "huffman.txt";
        //将压缩文件名转化成const char* 类型
        FILE* fw = fopen(compressFile.c_str(),"w");
        if(fw == NULL)
        {
            perror("fopen compressFile is error");
            return;
        }
        //将原文件指针移动到文件开头的位置
        fseek(fd, 0, SEEK_SET);
        ch = fgetc(fd);
        unsigned char value = 0;
        int count = 0;
        /*fputc('a',fw);*/
        while(ch != EOF)
        {
            code = _infor[ch]._code;//获取读取的字符的编码
            for(size_t i = 0; i < code.size(); i++)
            {
                value <<= 1;
                value |= (code[i]-'0');
                if(++count == 8)//一个字节8个比特位
                {
                    fputc(value,fw);
                    value = 0;
                    count = 0;
                }

            }
            ch = fgetc(fd);
        }
        if(count < 8)
        {
            value <<= 8 - count;
            fputc(value,fw);
        }   
        fclose(fw);
        fclose(fd);
         //解压缩
        Uncompress(compressFile.c_str());
    }
    //生成Huffman编码
    //两种方法：递归法一（从下往上，最后逆置）和递归法二（从上往下直接生成）
    //递归法一
    void CreateHuffmanCode(Node* root)
    {
        if(NULL == root)
            return;
        if(root->_left == NULL && root->_right == NULL)//叶子节点
        {
            Node* cur = root;
            Node* parent = cur->_parent;
            string& code = _infor[cur->_data._ch]._code;
            while(parent)
            {
                if(parent->_left == cur)
                {
                    code.push_back('0');
                }
                else
                {
                    code.push_back('1');
                }
                cur = parent;
                parent = cur->_parent;
            }
            //逆置
            reverse(code.begin(),code.end());
            _infor[root->_data._ch]._code = code;
            return;
        }
        CreateHuffmanCode(root->_left);
        CreateHuffmanCode(root->_right);
    }
    //递归法二
    void CreateHuffmanCodeR(Node* root,string& code)//递归法
    {
        if(NULL == root)
            return;
        if(root->_left == NULL && root->_right == NULL)
        {
            _infor[root->_data._ch]._code = code;
            return;
        }
        CreateHuffmanCodeR(root->_left,code+'0');
        CreateHuffmanCodeR(root->_right,code+'1');
    }
    //解压缩
    void Uncompress(const char* filename)//传入的文件是压缩文件
    {
        assert(filename);
        string uncompressFile = filename;//生成解压缩文件
        size_t point = uncompressFile.rfind('.');
        assert(point != string::npos);
        uncompressFile = uncompressFile.substr(0,point);
        uncompressFile += "uncompressFile.txt";
        FILE* fw = fopen(uncompressFile.c_str(),"w");
        if(NULL == fw)
        {
            perror("open uncompressFile is error");
            return;
        }
        //重构Huffman树
        charInfo invalid;
        invalid._count = 0;
        HuffmanTree<charInfo> hufftree(_infor,256,invalid);
        Node* root = hufftree.GetRoot();
        LongType count = root->_data._count;//求出所有字符出现的次数之和
        FILE* fr = fopen(filename,"r");//以只读的方式打开压缩文件
        if(NULL == fr)
        {
            perror("fopen uncompressFile is error");
            return;
        }

        unsigned char ch = fgetc(fr);
        Node* cur = root;
        while(ch != EOF)
        {
            for(int pos = 7; pos >= 0; --pos)
            {
                if((1<<pos) & ch)//说明是1,右边
                {
                    cur = cur->_right;
                }
                else//说明是0，左边
                {
                    cur = cur->_left;
                }
                if(cur->_left == NULL && cur->_right == NULL)//到叶子节点
                {
                    fputc(cur->_data._ch,fw);
                    if(--count == 0)//字符已经读完了
                    {
                        break;
                    }
                    cur = root;
                }
            }
            if(count == 0)
                break;
            ch = fgetc(fr);
        }
        fclose(fr);
        fclose(fw);
    }

};

那么这样写会不会感觉很尴尬，压缩文件和解压文件一起执行？当然不行了，所以这时候我们就需要将我们的信息进行配置存储，然后一起放入压缩文件中，等解压的时候重新配置我们的信息，构建我们Huffman树，然后解压缩，这样就可以将压缩和解压缩分开进行了。

见如下改进版本：


#include<assert.h>
#include<string>
#include"HuffmanTree_review.h"

typedef long LongType;
struct charInfo
{
    unsigned char _ch;//字符
    LongType _count;//字符出现的次数
    string _code;//字符的huffman编码

    charInfo operator+(const charInfo& t)const
    {
        charInfo ret;
        ret._count = _count + t._count;
        return ret;
    }
    bool operator<(const charInfo& t)const
    {
        return this->_count < t._count;
    }

    bool operator!=(const charInfo& t)const
    {
        return this->_count != t._count;
    }
};
//压缩文件类
class FileCompress
{
    typedef HuffmanTreeNode<charInfo> Node;
protected:
    //字符读写
    charInfo _infor[256];
    //二进制读写
    struct _NodeInfo
    {
        unsigned char _ch;
        LongType _count;
    };
public:
    FileCompress()
    {
        //初始化数组
        for(size_t i = 0; i < 256; ++i)
        {
            _infor[i]._ch = i;
            _infor[i]._count = 0;
        }
    }
    //统计字符出现的次数
    //创建Huffman树
    void Compress(const char* filename)
    {
        //统计所有字符出现的次数
        assert(filename);
        FILE* fd = fopen(filename,"rb");
        if(NULL == fd)
        {
            perror("open file is error");
            return;
        }
        int ch = fgetc(fd);//获取第一个字符
        while(ch != EOF)
        {
            _infor[ch]._count++;
            ch = fgetc(fd);
        }
        //构建Huffman树
        charInfo invalid;
        invalid._count = 0;//出现次数<=0的直接丢弃
        HuffmanTree<charInfo> heap(_infor,256,invalid);
        //生成Huffman编码
        /*string code;
        CreateHuffmanCodeR(heap.GetRoot(),code);*/
        CreateHuffmanCode(heap.GetRoot());

        //压缩
        //生成压缩文件，将压缩信息存储在压缩文件中
        string compressFile = filename;
        compressFile += "huffman.txt";
        //将压缩文件名转化成const char* 类型
        FILE* fwb = fopen(compressFile.c_str(),"wb");//以二进制的读写方式打开
        if(fwb == NULL)
        {
            perror("fopen compressFile is error");
            return;
        }

        //配置文本信息，将字符信息重新打包封装好放入压缩文件中
        for(size_t i = 0; i < 256; i++)
        {
            if(_infor[i]._count != 0)
            {
                _NodeInfo info;
                info._ch = _infor[i]._ch;
                info._count = _infor[i]._count;
                size_t size = fwrite(&info,sizeof(_NodeInfo),1,fwb);
                assert(size != sizeof(_NodeInfo));
            }
        }
        //这个类似于设置一个结尾信息，以便于后期提取信息
        _NodeInfo info;
        info._count = 0;
        size_t size = fwrite(&info,sizeof(_NodeInfo),1,fwb);
        assert(size != sizeof(_NodeInfo));



        ////将压缩文件名转化成const char* 类型
        //FILE* fw = fopen(compressFile.c_str(),"w");
        //if(fw == NULL)
        //{
        //  perror("fopen compressFile is error");
        //  return;
        //}
        //将原文件指针移动到文件开头的位置
        fseek(fd, 0, SEEK_SET);
        ch = fgetc(fd);
        unsigned char value = 0;
        int count = 0;
        while(ch != EOF)
        {
            string& code = _infor[ch]._code;//获取读取的字符的编码
            for(size_t i = 0; i < code.size(); i++)
            {
                value <<= 1;
                value |= (code[i]-'0');
                if(++count == 8)//一个字节8个比特位
                {
                    fputc(value,fwb);
                    value = 0;
                    count = 0;
                }

            }
            ch = fgetc(fd);
        }
        if(count < 8)
        {
            value <<= 8 - count;
            fputc(value,fwb);
        }

        //解压缩

        /*fseek(fw,0,SEEK_SET);*/
        fclose(fwb);
        fclose(fd);

        /*Uncompress(compressFile.c_str());*/

    }
    //生成Huffman编码
    //两种方法：递归法一（从下往上，最后逆置）和递归法二（从上往下直接生成）
    //递归法一
    void CreateHuffmanCode(Node* root)//非递归法
    {
        if(NULL == root)
            return;
        if(root->_left == NULL && root->_right == NULL)//叶子节点
        {
            Node* cur = root;
            Node* parent = cur->_parent;
            string& code = _infor[cur->_data._ch]._code;
            while(parent)
            {
                if(parent->_left == cur)
                {
                    code.push_back('0');
                }
                else
                {
                    code.push_back('1');
                }
                cur = parent;
                parent = cur->_parent;
            }
            //逆置
            reverse(code.begin(),code.end());
            _infor[root->_data._ch]._code = code;
            return;
        }
        CreateHuffmanCode(root->_left);
        CreateHuffmanCode(root->_right);
    }
    //递归法二
    void CreateHuffmanCodeR(Node* root,string& code)//递归法
    {
        if(NULL == root)
            return;
        if(root->_left == NULL && root->_right == NULL)
        {
            _infor[root->_data._ch]._code = code;
            return;
        }
        CreateHuffmanCodeR(root->_left,code+'0');
        CreateHuffmanCodeR(root->_right,code+'1');
    }
    //解压缩
    void Uncompress(const char* filename)//传入的文件是压缩文件
    {
        assert(filename);
        string uncompressFile = filename;//生成解压缩文件
        size_t point = uncompressFile.rfind('.');
        assert(point != string::npos);
        uncompressFile = uncompressFile.substr(0,point);
        uncompressFile += "uncompressFile.txt";
        FILE* fw = fopen(uncompressFile.c_str(),"w");
        if(NULL == fw)
        {
            perror("open uncompressFile is error");
            return;
        }

        ////以文本读写的方式打开压缩文件
        //FILE* fr = fopen(filename,"r");//以只读的方式打开压缩文件
        //if(NULL == fr)
        //{
        //  perror("fopen uncompressFile is error");
        //  return;
        //}

        //以二进制读写的方式打开压缩文件
        FILE* frb = fopen(filename,"rb");//以只读的方式打开压缩文件
        if(NULL == frb)
        {
            perror("fopen uncompressFile is error");
            return;
        }
        //恢复数组的配置信息
        while(1)
        {
            _NodeInfo info;
            size_t size = fread(&info,sizeof(_NodeInfo),1,frb);
            assert(size != sizeof(_NodeInfo));
            if(info._count > 0)
            {
                _infor[info._ch]._ch = info._ch;
                _infor[info._ch]._count = info._count;
            }
            else
                break;//退出
        }

        //重构Huffman树
        charInfo invalid;
        invalid._count = 0;
        HuffmanTree<charInfo> hufftree(_infor,256,invalid);
        Node* root = hufftree.GetRoot();
        LongType count = root->_data._count;//求出所有字符出现的次数之和

        int ch = fgetc(frb);
        Node* cur = root;
        while(ch != EOF)
        {
            for(int pos = 7; pos >= 0; --pos)
            {
                if((1<<pos) & ch)//说明是1,右边
                {
                    cur = cur->_right;
                }
                else//说明是0，左边
                {
                    cur = cur->_left;
                }
                if(cur->_left == NULL && cur->_right == NULL)//到叶子节点
                {
                    fputc(cur->_data._ch,fw);
                    if(--count == 0)//字符已经读完了
                    {
                        break;
                    }
                    cur = root;
                }
            }
            if(count == 0)
                break;
            ch = fgetc(frb);
        }
        /*fclose(fr);*/
        fclose(frb);
        fclose(fw);
    }

};


void TestFileCompress()
{
    /*const char* filename = "filecompresstest.txt";*/
    FileCompress compress;
    /*compress.Compress("filecompresstest.txt");*/
    compress.Uncompress("filecompresstest.txthuffman.txt");

}

项目补充：
问：文件压缩一定会压小吗？
答：不一定；当编码<8的时候，压缩节省空间可以实现当编码>8时，压缩反而增大；当文件字符出现的次数频率都差不多的时候，不会起到压缩效果，而字符出现次数相差较大时会有压缩效果。

问：一个文件是否可以多次压缩，越压越小？
答：错，一般第一次压缩效果最好。

问：Huffman压缩的意义是什么？
答：实际应用其实是zip压缩。

angry_youth
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Huffman Tree——文件压缩
青云衣兮白霓裳
05-08 536
1 Huffman树的压缩和解压缩原理 2 文件压缩（Huffman树的实战应用） 2.1 原理分析 2.2 代码实现 //Heap.h #pragma once #include &amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;string&amp;amp;gt; #include&amp;amp;lt;vector&amp;amp;gt; #include&amp;quot;as
Huffman树实现解压缩文件
liyangxueit的博客
12-21 311
代码是根据尚硅谷韩顺平老师写的，发现有错误，先放着留着学习吧。 package com.attongji.huffmancode; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.ObjectInputStream; impo...
哈夫曼树(HuffmanTree)
cj1561435010的博客
03-05 1006
一、哈夫曼树简介 1、构建哈夫曼树        计算每个字符出现的概率，将这个概率做为权值之比。        利用这些带权值的字符构建出哈夫曼树。        具体构建步骤： &nb...
基于HuffmanTree的文件压缩及解压
mac_timmy
04-05 503
个人博客传送门 HuffmanTree 定义 名词解释 性质 创建HuffmanTree 节点定义 构造函数 参数解释 构建的思想 析构函数 获取根节点函数 补充 文件压缩及解压缩 哈夫曼编码 压缩思路 压缩原理 压缩与解压代码分析 结构体分析 构造函数 压缩函数 构建哈夫曼编码函数 解压函数 代码 HuffmanTree 定义 哈弗曼树是一种...
【数据结构】中的哈弗曼树-HuffmanTree
LX18792732127的博客
04-03 639
【数据结构】中的哈弗曼树（HuffmanTree）
哈夫曼编码 (Huffman code)的实现，压缩、解压缩
热门推荐
程书画的 BLOG
09-04 2万+
此程序首先扫描一遍输入文件并统计各个字符的出现次数，然后对结果排序，再由此构造Huffman树，然后对树进行一个遍历，并把各个字符的Huffman编码存到一个hash表中，所谓hash表就是建立一个string数组，数组下标用字符的ASCII码表示，数组内容用此字符对应的Huffman编码表示，例如，a:11，则 hash['a'] = "11"; 然后重新对文件进行一遍扫描，根据hash表进行
链表HuffmanTree-c语言文件读写
最新发布
06-26
在这个特定的场景中，我们关注的是使用C语言实现的哈夫曼树（Huffman Tree），这是一种特殊的二叉树，广泛应用于数据压缩。哈夫曼编码是哈夫曼树的应用，它可以有效地对数据进行编码，从而提高存储和传输效率。 ...
基于Huffman树的文件压缩C源码
12-24
总结来说，"基于Huffman树的文件压缩C源码"涉及了数据结构（二叉树）、算法（Huffman编码）以及文件I/O操作，是一个综合性的编程实践项目。通过理解Huffman编码的工作原理和C语言的实现，可以更好地掌握数据压缩技术...
HuffmanTree文件压缩 - 快捷方式.zip
08-25
在这个“HuffmanTree文件压缩 - 快捷方式.zip”项目中，我们可以深入理解C++如何实现哈夫曼编码的过程。 哈夫曼编码的核心思想是：频繁出现的字符使用较短的编码，不频繁出现的字符使用较长的编码。这样，频繁出现...
C语言-基于哈夫曼树的数据压缩算法.zip
11-15
哈夫曼编码是一种高效的数据压缩算法，它利用了字符出现频率的不同来构建特殊的二叉树——哈夫曼树（Huffman Tree），进而为每个字符分配一个唯一的二进制编码，频繁出现的字符会得到较短的编码，不常出现的字符则...
HuffmanCode-master_C语言_哈夫曼树_
10-01
每次从堆顶取出两个权值最小的树，合并成一个新的树，新树的权值为两棵子树权值之和，然后将新树插入堆中。重复这个过程，直到堆中只剩下一个元素，即为哈夫曼树的根节点。 3. **编码过程**：从哈夫曼树的根节点...
搜索二叉树
angry_youth的博客
05-05 4327
概念：搜索二叉树是一种特殊有序的二叉树，如果一棵树不为空，并且如果它的根节点左子树不为空，那么它左子树上面的所有节点的值都小于它的根节点的值，如果它的右子树不为空，那么它右子树任意节点的值都大于他的根节点的值，它的左右子树也是二叉搜索树。 由此可见，如果对二叉搜索树进行中序排列（左中右），那么会得到一个从小到大的序列。 上图中序排列（左中右）后的顺序应该是： 5，6，8，9，10，15，16，1...
最小生成树图之-Prim算法和Kruskal算法
angry_youth的博客
05-25 1430
最小生成树算法： 结合上一章学习了解了图的基本概念，接下来了解一下最小生成树的两种算法。 Prim算法（普里姆算法）： 思想：找到所有最短的权值连接的顶点集合，所组成的树是最小生成树。 从某一顶点为起点，逐步找各个顶点上的最小权值的边来构建最小生成树。 首先，从根节点A开始，我们发现A到对所有顶点的权值信息如下： 找到最小权值，权值必须有意义，我们这里的有意义暂定为：权值要大于0，且不能为无穷大。 找到第一个最近的顶点B后，同时更新A点到各个顶点的距离，此时B点已经访问过了，我们需要标识它防止下一次它再
栈的分析和详解
angry_youth的博客
05-13 710
栈
HashTable，位图，BloomFilter分析（简单粗暴）
angry_youth的博客
08-09 679
**HashTable:（散列表/哈希表）** 是根据关键字key而直接访问在内存存储位置的数据结构；它通过一个关键值的函数将所需的数据映射到表中的位置来访问数据，这个映射函数叫做散列函数，存放记录的数组叫做散列表； 构造哈希表的几种方法： 1)直接定址法：取关键字的某个线性函数为散列地址；（但数值之间相差较大，该方法不可用） 2)除留余数法：取关键值被某个不大于散列表长m的数p除后的所得的
线索化二叉树
angry_youth的博客
07-26 675
**线索化：**能够对这颗树进行非递归遍历；能够给这棵树加上迭代器；线索化避免了这棵树遍历时的递归回旋问题，使用一个循环一口气就可以将这棵树访问完毕，可以这么理解，树的本身访问到了叶子节点就出现了断点问题，就要开始递归回旋判断，然而我们使用了线索化以后就相当于将断点问题解决，这就是一条可以直达终点的通路。 可以用两句话概括： A. 如果当前节点没有左孩子，就让左孩子指向父亲，同时让其节点类型变
栈和递归---解决迷宫问题
angry_youth的博客
07-22 579
迷宫问题:走过的路设置为2，未走过的路设置0，墙设置为1； - 解决方法一：栈stack将每次你所走过的路都push进入栈里面，栈顶元素的坐标就是你所在的位置，取出你所在的位置然后判断当前位置上下左右四个方向是否有通路，如果没有就pop()顶层元素，然后再取出顶层元素（即退一步），然后接着判断其他方向是否有通路，直到你走出边界或者栈为空的时候退出； 缺陷：只找到一条路径就退出，无法判断最短路
基于Huffman编码的文件压缩与解压缩设计详解
在"数据结构课程设计-基于Huffman编码的文件压缩与解压缩20分-内容与要求.docx"文档中，主要讨论的是一个关于数据结构课程的设计任务，具体要求学生使用C++语言实现Huffman编码来实现文件的压缩与解压缩功能。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值