哈夫曼编码（解压，压缩）

最新推荐文章于 2022-07-01 17:53:32 发布
最新推荐文章于 2022-07-01 17:53:32 发布
阅读量340 收藏 5
点赞数 3
分类专栏： 数据结构和算法实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keyboardnobug/article/details/116300075
版权
本文详细介绍了如何使用哈夫曼编码进行文件的加压缩与解压操作，包括Huffman Tree的构建、编码算法、解码过程以及实际应用案例。从创建Huffman Tree到实现文件的位级压缩，展示了整个编码解码流程。
摘要由CSDN通过智能技术生成

哈夫曼编码

哈夫曼编码加压缩，解压

// HuffmanTree.h

//   HuffmanTree.h 

#ifndef HUFFMANTREE_H
#define HUFFMANTREE_H
#include<bits/stdc++.h>
using namespace std;

typedef struct Hufnode
{
    int rt,lchild,rchild,w;
}Hufnode,*Huftree;

class HuffmanTree
{
    public:
        void CreatHuf(int n,int *word);
    public:
        Hufnode *Hfm;
        int num,tot; //
};

#endif // HUFFMANTREE_H

// HuffmanTree.cpp

// HuffmanTree.cpp

#include "HuffmanTree.h"
#include<bits/stdc++.h>
using namespace std;
//typedef pair<int,int>pair<int,int>;
void HuffmanTree::CreatHuf(int n,int *word)
{
    num=n;
    tot=2*num-1;
    Hfm=new Hufnode[tot+1];
    for(int i=1;i<=tot;i++) // 完全初始化
    {
        Hfm[i].w=0;
        Hfm[i].rt=0;
        Hfm[i].lchild=0;
        Hfm[i].rchild=0;
    }
    priority_queue< pair<int,int>,vector< pair<int,int> >,greater< pair<int,int> > > que; //优先队列返回最小值
    for(int i=1;i<=n;i++)
    {
        Hfm[i].w=word[i];
        que.push(make_pair(Hfm[i].w,i));
    }
    for(int i=n+1;i<=tot;i++)
    {
        int min_1,min_2;
        min_1=que.top().second;
        que.pop();
        min_2=que.top().second;
        que.pop();
        Hfm[i].lchild=min_1;
        Hfm[i].rchild=min_2;
        Hfm[min_1].rt=i;
        Hfm[min_2].rt=i;
        Hfm[i].w=Hfm[min_1].w+Hfm[min_2].w;
        que.push(make_pair(Hfm[i].w,i));
    }
}

// main.cpp

//  main.cpp
#include<bits/stdc++.h>
#include<windows.h>
#include "HuffmanTree.h"
using namespace std;
typedef char **HuffmanCode; //哈夫曼编码表
int word[300];
HuffmanCode HC;
map<char,int> mp;// 字母对应编号
map<int,char> decmp; // 编号对应字母
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int n) // 哈夫曼编码
{
	HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
	char *cd=new char [n];
	cd[n-1]='\0';
	for(int i=1;i<=n;i++)
	{
		int start=n-1;
		for(int j=i,fa=HT.Hfm[i].rt;fa!=0;j=fa,fa=HT.Hfm[fa].rt)
        {
            if(HT.Hfm[fa].lchild==j) cd[--start]='0';
			else cd[--start]='1';
        }
		HC[i]=(char*)malloc((n-start)*sizeof(char));
		strcpy(HC[i],&cd[start]);
	}
	delete cd;
}
void Menu_Show()
{
    cout<<"**********************************************************************"<<endl;
    cout<<"*                        哈夫曼编码译码器                            *"<<endl;
    cout<<"*            1、选择需要进行编码的文件                               *"<<endl;
    cout<<"*            2、建立哈夫曼树                                         *"<<endl;
    cout<<"*            3、建立密码本并对文件编码                               *"<<endl;
    cout<<"*            4、选择需要进行解码的文件并解码                         *"<<endl;
    cout<<"*            5、按位压缩方式对文件进行压缩                           *"<<endl;
    cout<<"*            6、对压缩的文件进行解压                                 *"<<endl;
    cout<<"*            7、对解压缩的文件进行解码                               *"<<endl;
    cout<<"*            输入其他任意数字退出                                    *"<<endl;
    cout<<"**********************************************************************"<<endl;
}
void Option_1(int &n)
{
    DWORD startTime=GetTickCount();
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt");
    char c;
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\原文.txt");
    mp.clear();
    int tot=0;
    while(in.get(c))
    {
        if(mp[c]==0)
        mp[c]=(++tot),decmp[tot]=c;
        word[mp[c]]++;
    }
    cout<<"              编码的文件读入成功"<<endl;
    n=tot;
    in.close();
    DWORD endTime=GetTickCount();
    out<<"读入要编码的文件运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Option_2(HuffmanTree&hf,int n)
{
    DWORD startTime=GetTickCount();
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    hf.CreatHuf(n,word);
    cout<<"              哈夫曼树已成功建立"<<endl;
    cout<<"              ***哈夫曼树如下***\n"<<endl;
    cout<<"编号    权 值    父节点    左子节点    右子节点\n";
    for(int i=1;i<=hf.tot;i++)
    {
        printf("%4d    %4d     %4d       %4d       %4d\n",i,hf.Hfm[i].w,hf.Hfm[i].rt,hf.Hfm[i].lchild,hf.Hfm[i].rchild);
    }
    DWORD endTime=GetTickCount();
    out<<"建立哈夫曼树并输出哈夫曼树运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Option_3(HuffmanTree hf,int n)
{
    DWORD startTime=GetTickCount();
    ofstream outf("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    HuffmanCoding(hf,HC,n);
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\哈夫曼编码文.txt");
    cout<<"              密码本已成功建立  "<<endl;
    cout<<"              ***如下***        "<<endl;
    for(int i=1;i<=n;i++)
    {
        if(decmp[i]=='\n') cout<<"Enter";
        else cout<<decmp[i];
        cout<<"  :";
        cout<<HC[i]<<endl;
    }
    char c;
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\原文.txt");
    while(in.get(c))
    {
        out<<HC[mp[c]];
    }
    out.close();
    in.close();
    DWORD endTime=GetTickCount();
    outf<<"建立密码本并编码运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Option_4(HuffmanTree hf,int n)
{
    DWORD startTime=GetTickCount();
    ofstream outf("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\哈夫曼编码文.txt");
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\哈夫曼解码文.txt");
    int now=2*n-1;
    char c;
    while(in.get(c))
    {
        if(c=='1') now=hf.Hfm[now].rchild;
        else now=hf.Hfm[now].lchild;
        if(hf.Hfm[now].rchild==0 && hf.Hfm[now].lchild==0)
        {
            out<<decmp[now];
            now=2*n-1;
        }
    }
    in.close();
    out.close();
    DWORD endTime=GetTickCount();
    outf<<"解码哈夫曼编码文运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Option_5()
{
    DWORD startTime=GetTickCount();
    ofstream outf("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\哈夫曼编码文.txt");
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\压缩文.cod",ios::binary);
    char c;
    int flag=0,tmp=0,n1=0,n2=0;
    while(in.get(c))
    {
        flag++;
        n1++;
        tmp=tmp*2+c-'0';
        if(flag==8)
        {
            n2++;
            flag=0;
            out<<(unsigned char)(tmp);
            tmp=0;
        }
    }
    if(flag%8!=0) out<<(unsigned char)(tmp),n2++;
    out<<(unsigned char)(flag%8);
    n2++;
    cout<<"                              ***压缩成功***    "<<endl;
    in.close();
    out.close();
    cout<<"压缩比为  ：";
    cout<<(100.0*n2)/n1<<"%"<<endl;
    DWORD endTime=GetTickCount();
    outf<<"压缩哈夫曼编码文运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Unzip()
{
    DWORD startTime=GetTickCount();
    ofstream outf("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    ifstream inf("D:\\C,C++\\数据结构\\HuffmanCode\\压缩文.cod",ios::binary);
    inf.seekg(0,ios::end);
    int n=inf.tellg();
    inf.close();
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\压缩文.cod",ios::binary);
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\解压编码文.txt");
    char c;
    while(in.get(c))
    {
        unsigned char ch=c;
        int ans=(int)ch;
        if(n==2)
        {
            in.get(c);
            ch=c;
            int t=(int)ch;
            int res=pow(2,t-1);
            for(int i=t-1;i>=0;i--)
            {
                int tmp=ans/res;
                ans%=res;
                res/=2;
                out<<tmp;
            }
            break;
        }
        int res=pow(2,7);
        for(int i=7;i>=0;i--)
        {
            int tmp=ans/res;
            ans%=res;
            res/=2;
            out<<tmp;
        }
        n--;
    }
    cout<<"                              ***解压成功***    "<<endl;
    in.close();
    out.close();
    DWORD endTime=GetTickCount();
    outf<<"解压压缩文运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
void Transfer(HuffmanTree hf,int n)
{
    DWORD startTime=GetTickCount();
    ofstream outf("D:\\C,C++\\数据结构\\HuffmanCode\\计时.txt",ios::app);
    ifstream in("D:\\C,C++\\数据结构\\HuffmanCode\\解压编码文.txt");
    ofstream out("D:\\C,C++\\数据结构\\HuffmanCode\\解压哈夫曼解码文.txt");
    cout<<"                              ***解压码文如下***    "<<endl;
    int now=2*n-1;
    char c;
    while(in.get(c))
    {
        if(c=='1') now=hf.Hfm[now].rchild;
        else now=hf.Hfm[now].lchild;
        if(hf.Hfm[now].rchild==0 && hf.Hfm[now].lchild==0)
        {
            out<<decmp[now];
            now=2*n-1;
        }
    }
    in.close();
    out.close();
    DWORD endTime=GetTickCount();
    outf<<"将解压缩后的哈夫曼编码解码运行时间为：:"<<endTime-startTime<<"ms"<<endl;
}
int main()
{
    HuffmanTree hf;
    int n;
    while(true)
    {
        system("pause");
        system("cls");
        Menu_Show();
        int m1;
        cout<<"请输入你要进行的操作  :";
        cin>>m1;
        switch(m1)
        {
            case 1:Option_1(n);   break;
            case 2:Option_2(hf,n);break;
            case 3:Option_3(hf,n);break;
            case 4:Option_4(hf,n);break;
            case 5:Option_5();    break;
            case 6:Unzip();       break;
            case 7:Transfer(hf,n);break;
            default:return 0;     break;
         }
    }
    return 0;
}
'Profat
关注
专栏目录
哈夫曼编码（带中文压缩）
01-03
利用优先级队列+DFS优化的哈夫曼编码译码器，可进行中文压缩，最高压缩率可达到1:3
运用哈夫曼树实现哈夫曼编码的文件压缩与解压
大哥的叔的博客
08-15 1万+
package com.HuffmanTree; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java....
24 哈夫曼编码实现字符串的压缩与解压
朱古力的博客
07-02 912
哈夫曼编码 文章目录哈夫曼编码1. 步骤2. 数据压缩3. 数据解压 1. 步骤 传输的字符串：i like like like java do you like a java。 计算各个字符对应的个数。 按照字符出现的次数构建一颗赫夫曼树, 次数作为权值。 根据赫夫曼树，给各个字符,规定编码 (前缀编码)， 向左的路径为 0 向右的路径为 1。则有，o: 1000 u: 10010 d: 100110 y: 100111 i: 101 a : 110 k: 1110 e: 1111 j: 0000
通过哈夫曼编码对文件进行解压缩
weixin_44827241的博客
03-16 518
public class HuffmanCode{ public static void main(String[] args) { // 测试压缩文件 // String srcFile = "源文件路径"; // String dstFile = "压缩文件路径"; // // zipFile(srcFile, dstFile); // System.out.println("压缩文件 ok~~"); // 测试解压文件 String zipFile =
哈夫曼编码 (Huffman code)的实现，压缩、解压缩
程书画的 BLOG
09-04 2万+
此程序首先扫描一遍输入文件并统计各个字符的出现次数，然后对结果排序，再由此构造Huffman树，然后对树进行一个遍历，并把各个字符的Huffman编码存到一个hash表中，所谓hash表就是建立一个string数组，数组下标用字符的ASCII码表示，数组内容用此字符对应的Huffman编码表示，例如，a:11，则 hash['a'] = "11"; 然后重新对文件进行一遍扫描，根据hash表进行
C语言实现哈夫曼编码压缩和解压各种文件
11-19
实验内容：写出程序，利用哈弗曼编码实现对文件的压缩，并能解压文件。 实验步骤： 1、压缩 （1） 统计原始文件中各字节出现的概率（次数）； （2） 采用哈弗曼算法对各字节进行编码，建立哈弗曼对照表； a) 构造...
哈夫曼编码压缩解压.rar
03-13
在Java中实现哈夫曼编码压缩和解压，你需要以下几个关键步骤： 1. **编码阶段**： - 实现哈夫曼树的构建算法，如上述描述。 - 为每个字符生成哈夫曼编码，并存储在一个映射表中，以便后续解码使用。 - 遍历原始...
哈夫曼编码压缩和解压缩文件——C++实现
01-20
哈夫曼编码是一种数据压缩方法，它通过构建最优的二叉树（哈夫曼树）来为字符分配编码，使得最频繁出现的字符拥有最短的编码，从而达到压缩数据的目的。在C++中实现哈夫曼编码压缩和解压缩文件涉及到几个关键步骤： ...
Huffman 编码图像无损压缩和解压缩 Python示例代码 哈夫曼编码
最新发布
08-13
本程序实现了利用 Huffman 编码对图像进行无损压缩和解压缩。Huffman 编码是一种基于字符出现频率构建相应前缀码的无损数据压缩算法。 使用方法： 1. 需要安装 OpenCV 和 Numpy 库： pip install opencv-python ...
文档压缩_哈夫曼编码_压缩解压_
10-02
哈夫曼编码是一种高效的数据压缩方法，由大卫·哈夫曼在1952年提出。它是基于一种称为“最小带权路径长度”的算法构建的，适用于无损数据压缩。在哈夫曼编码中，频繁出现的字符会被赋予较短的编码，而不太常见的字符...
哈夫曼编码压缩解压缩程序（CPP写的）
06-12
哈夫曼编码压缩解压缩程序（CPP写的） 多媒体课程设计中也许能用的到 希望能帮到能用的到的人
关于哈夫曼编码压缩文件
minose的博客
05-02 788
参考Crash Course的课程，做下笔记，原视频在这里 ↓ https://www.bilibili.com/video/BV1EW411u7th?p=21 我们要对如下一张 4像素 X 4像素的 图片进行压缩， 而在磁盘中图片是一串像素值的形式存储的，每个像素的颜色由RGB确定，这样一张图片需要 48（16*3） 个字节 为了能够压缩图片，我们需要减少冗余的信息或者用更紧凑的表示方...
数据结构实验6：哈夫曼编码实现文本压缩
weixin_51502608的博客
07-01 1713
两个功能 输入字符串，输出字符串的哈夫曼编码 输入文本文件（英文），输出哈夫曼编码文件 附加：解压缩，即给出哈夫曼编码文件和哈夫曼树，恢复原始字符串文件。功能一：输入字符串，输出字符串的哈夫曼编码功能二：输入文本文件（英文），输出哈夫曼编码文件功能三：解压缩，即给出哈夫曼编码文件和哈夫曼树，恢复原始字符串文件。...
哈夫曼压缩与解压缩
热门推荐
飞鸿踏雪泥的博客
08-13 3万+
哈夫曼压缩与解压缩 目录 哈夫曼压缩与解压缩 一：引言 二：主要技术点 三：过程介绍 1、压缩： 2、解压缩 四：详细分析 一：准备过程 二：压缩 三：解压缩 五：结果演示 六：总结 七：源码地址 一：引言 之前的两个贪吃蛇和巨大数的练习，总体来说难度不大，有好的算法和比较新颖的微译码补码。但是，哈夫曼压缩与解压缩可以说难度比前两个大得多，涉及的知识面更加广。做完这...
基于哈夫曼树的数据压缩算法
ଳxin的博客
05-30 2498
题目描述 输入一串字符串，根据给定的字符串中字符出现的频率建立相应哈夫曼树，构造哈夫曼编码表，在此基础上可以对待压缩文件进行压缩（即编码），同时可以对压缩后的二进制编码文件进行解压（即译码）。 输入： 多组数据，每组数据一行，为一个字符串（只考虑26个小写字母即可）。当输入字符串为“0”时，输入结束。 输出： 每组数据输出4行: 第一行为统计出来的字符出现频率（只输出存在的字符，格式为：字符：频度...
哈夫曼编码实现文本压缩和解压（C++）
yshshhgxq的博客
11-08 1万+
哈弗曼树：又称最优二叉树，是带权路径长度最短的树。 哈夫曼编码：是一种前缀编码，即同一字符集中任何一个字符的编码都不是另外一个字符编码的前缀（最左子串）。         在哈弗曼树中，若用‘0’表示左子树，‘1’表示右子树，那么每当从根遍历到一个叶子节点时都会形成一个01串，即该叶子节点的编码，由于各个叶子节点已经是树的最末梢了，因此他们之间的编码不会有包含关系，这样就生成了前缀编码集。 ...
huffman编码_哈夫曼编码
weixin_39604983的博客
11-27 711
最近在看HTTP2中，发现头部压缩算法HPACK中使用了哈夫曼编码（Huffman Coding）。借机总结一下～提纲如下：简介前置知识为什么要压缩数据固定长度压缩算法哈夫曼压缩算法1.简介霍夫曼编码是MIT的David A. Huffman担任科学博士学位期间开发的一种算法，霍夫曼算法的输出可以视为可变长度（variable-length code）代码表，用于对源符号进行编码，进行数据压缩。2...
数据结构编程实践（七）创建哈夫曼树、生成哈夫曼编码、完成图片的压缩与解压缩
青红造了个大白之成长记
07-11 1万+
一、对图片的压缩与解压缩，涉及以下内容：1．文件读写2．创建Huffman树3．生成Huffman编码4．压缩图片文件5 .  解压缩图片文件 二、将项目分成三个小任务，下一任务是在上一任务的基础上完成：1．任务一：统计权值、创建Huffman树2．任务二：生成Huffman编码、保存压缩文件3．任务三：解压压缩文件，恢复原文件下面开始完整的步骤：三、统计权值、生成Huffman树1.Huffma...
用哈夫曼编码压缩图像
qq_45207442的博客
06-15 4480
最近在上图像处理的课，要完成的一些作业就顺便分享到这上面来了。本来是编辑好了，就贴代码就好了，但由于新手操作，一放代码就出问题导致心态崩了。所以就不讲原理了，试试看代码怎么放吧。真的难受，我打了这么多字。枯了。 原理就看下图吧。（怎么感觉变糊了，太折磨人了） 代码思路大概就是，我认为只有出现在最后两位最小的概率值需要加码字0或者1。所以就可以正向直接求每一个概率值的码字。比如说第一个概率a1，排...
哈夫曼编码：压缩与解压算法详解
- 在实际应用中，哈夫曼编码广泛应用于文本压缩、图像压缩等场景，尤其对于那些存在高频字符的数据，能够实现较高的压缩比。 通过理解和掌握哈夫曼树及其压缩解压原理，我们可以设计出高效的压缩算法，优化数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值