哈夫曼编码的一个实际应用（压缩与解压）

最新推荐文章于 2024-02-12 01:11:26 发布
最新推荐文章于 2024-02-12 01:11:26 发布
阅读量1w 收藏 18
点赞数 4
分类专栏： 模拟 文章标签： 压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyf199775/article/details/75033329
版权

在课堂上，我们学习了哈夫曼编码的原理和实现方法，上实验课时也动手实现过，后来我们又追加介绍了哈夫曼编码的实际压缩和解压缩的实现方法，并且在课堂上也演示了，但当时我们却忽略了一个环节，那就是实际文件存储时，二进制是比特位，而存储的单位一般是字节，显示时又是按照十六进制的。现在给你一个由字典里的字符组成的原文，用哈夫曼方法把该原文压缩成十六进制码。

Input

本问题有多组测试数据，第一行就是测试数据的组数nCase，对于每组测试数据，一共有四个部分，第一部分是一个字典（请注意，字典里可能含有空格！），原文本里面出现的任何字符一定在这个字典里面，并且已经按照使用频度从大到小顺序排列。第二部分是字典里相对应字符的使用频度。第三部分是原文的行数n。第四部分是n行原文。

Output

输出一共n行，每行就是原文对应的十六进制压缩码。

 

特别说明：

1：由于哈夫曼编码可能不一定唯一，因此我们规定在构建哈夫曼树时，左子树编码为0，右子树编码为1，左子树代表的频度数据小于右子树代表的频度数据，如果两个频度数据相同，则以生成早的为左子树，如果在字典里出现相同频度的字符，则原排在前的为左子树。这样规定目的是确保哈夫曼编码唯一。

2：如果在压缩过程中，用哈夫曼方法压缩后二进制码的长度不是8的倍数，在码的最后添数字‘0’使其长度成为8的倍数（注意最多添7个‘0’）。

Sample Input 

1
 AORST
60 22 16 13 6 4
3
 AO
ASAO RST ATOAATS  OSAATRR RRASTO
STROAR  SSRTOAAA

Sample Output 

7C
F3F2CC3C6FE24D3FC5AB7CC6
98BBD266C6FF80


下面是实现压缩的代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<map> 
#include<algorithm> 
using namespace std;

struct TREE{
    int l,r;
    int now,w;
    string str;

    TREE(){};
    TREE(int now,int w,string str)
    {
        this->now=now;
        this->w=w;
        this->str=str;
        this->l=this->r=-1;
    }
    TREE(int now,int w,string str,int l,int r)
    {
        this->now=now;
        this->w=w;
        this->str=str;
        this->l=l;
        this->r=r;
    }

    friend bool operator<(TREE a,TREE b)
    {
        if(a.w!=b.w) return a.w>b.w;
        else return a.now>b.now;
    }
};

int n,x,head;
string key,trans;
vector<TREE> tree;
priority_queue<TREE> q;
vector<bool> binary;
char hexa[20]="0123456789ABCDEF"; 

void buildTree()
{
    while(q.size()>1)
    {
        TREE tmp1=q.top();
        q.pop();
        TREE tmp2=q.top();
        q.pop(); 
        tree.push_back(TREE(tree.size(),tmp1.w+tmp2.w,tmp1.str+tmp2.str,tmp1.now,tmp2.now));
        q.push(tree[tree.size()-1]);
    }
    head=q.top().now;
    q.pop();
}

void toBinary(int t,string s)
{
    if(s==tree[t].str)
        return;
    int lc=tree[t].l;
    int rc=tree[t].r;
    if(lc==-1||rc==-1) 
        return;
    string tmp=tree[lc].str;
    if(tmp.find(s,0)!=string::npos)
    {
        binary.push_back(0);
        toBinary(lc,s);
    }
    else
    {
        binary.push_back(1);
        toBinary(rc,s);
    }
}

int main()
{
    ios::sync_with_stdio(false);    
    cin.tie(0); 
    int T;
    cin>>T;
    cin.get();
    while(T--)
    {
        getline(cin,key);
        for(int i=0;i<key.length();i++)
        {
            cin>>x;
            tree.push_back(TREE(i,x,key.substr(i,1)));
            q.push(tree[i]);
        }
        buildTree();
        cin>>n;
        cin.get();
        while(n--)
        {
            getline(cin,trans);
            for(int i=0;i<trans.length();i++)
                toBinary(head,trans.substr(i,1));
            while(binary.size()%8) 
                binary.push_back(0);
            for(int i=0;i<binary.size();i+=4)
            {
                int tmp=0,k=1;
                for(int j=3;j>=0;j--,k*=2)
                    if(binary[i+j]) tmp+=k;
                cout<<hexa[tmp];
            }
            cout<<endl;
            binary.clear();
        }
        tree.clear();
    }
}

在课堂上，我们学习了哈夫曼编码的原理和实现方法，上实验课时也动手实现过，后来我们又追加介绍了哈夫曼编码的实际压缩和解压缩的实现方法，并且在课堂上也演示了，但当时我们却忽略了一个环节，那就是实际文件存储时，二进制是比特位，而存储的单位一般是字节，显示时又是按照十六进制的。现在给你一个已经用哈夫曼方法压缩过的十六进制文件，请你解压以便还原成原文。

 

Input

本问题有多组测试数据，第一行就是测试数据的组数nCase，对于每组测试数据，一共有四个部分，第一部分是一个字典（请注意，字典里可能含有空格！），原文本里面出现的任何字符一定在这个字典里面，并且已经按照使用频度从大到小顺序排列。第二部分是字典里相对应字符的使用频度。第三部分是待解压的行数n。第四部分是n行经过哈夫曼压缩的十六进制数组成的字符串。

Output

输出一共n行，每行就是对应输入的原文（请注意，输出的原文里可能含有空格！）。

Sample Input 

1
 AORST
60 22 16 13 6 4
5
7C
F3F2CC3C6FE24D3FC5AB7CC6
98BBD266C6FF81
FE6517F5B6663AF98FE2226676FA80
F317262FCFE662FC99D7D

Sample Output 

 AO 
ASAO RST ATOAATS  OSAATRR RRASTO
STROAR  SSRTOAAA      ||Error !
AASS TRAA RRRSSTA RASTAATTTSSSOOAOR       
ASTRO STRAO AASSTRAO SSORAR

Hint

1：由于哈夫曼编码可能不一定唯一，因此我们规定在构建哈夫曼树时，左子树编码为0，右子树编码为1，左子树代表的频度数据小于右子树代表的频度数据，如果两个频度数据相同，则以生成早的为左子树，如果在字典里出现相同频度的字符，则原排在前的为左子树。这样规定目的是确保哈夫曼编码唯一。

2：如果在解压缩过程中，找不到对应的原文，那么在遇到错误后加上字符串“||Error !”，并停止对压缩串的解压。


下面是解压的代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<map> 
#include<algorithm> 
using namespace std;

struct TREE{
    int l,r;
    int now,w;
    string str;

    TREE(){};
    TREE(int now,int w,string str)
    {
        this->now=now;
        this->w=w;
        this->str=str;
        this->l=this->r=-1;
    }
    TREE(int now,int w,string str,int l,int r)
    {
        this->now=now;
        this->w=w;
        this->str=str;
        this->l=l;
        this->r=r;
    }

    friend bool operator<(TREE a,TREE b)
    {
        if(a.w!=b.w) return a.w>b.w;
        else return a.now>b.now;
    }
};

int n,x,head;
string key,trans;
vector<TREE> tree;
priority_queue<TREE> q;
queue<bool> binary;
map<char,int> hexa;

void buildTree()
{
    while(q.size()>1)
    {
        TREE tmp1=q.top();
        q.pop();
        TREE tmp2=q.top();
        q.pop(); 
        tree.push_back(TREE(tree.size(),tmp1.w+tmp2.w,tmp1.str+tmp2.str,tmp1.now,tmp2.now));
        q.push(tree[tree.size()-1]);
    }
    head=q.top().now;
    q.pop();
}

void toOrigin(int t)
{
    int lc=tree[t].l;
    int rc=tree[t].r;
    if(lc==-1||rc==-1)
    {
        cout<<tree[t].str;
        return;
    }
    if(binary.empty())
    {
        cout<<"||Error !";
        return;
    }
    if(!binary.front())
    {
        binary.pop();
        toOrigin(lc);
    }   
    else
    {
        binary.pop();
        toOrigin(rc);
    }
}

void init()
{
    for(int i=0;i<10;i++)
        hexa['0'+i]=i;
    for(int i=0;i<6;i++)
        hexa['A'+i]=10+i;
}

int main()
{
    ios::sync_with_stdio(false);    
    cin.tie(0); 
    int T;
    init();
    cin>>T;
    cin.get();
    while(T--)
    {
        getline(cin,key);
        for(int i=0;i<key.length();i++)
        {
            cin>>x;
            tree.push_back(TREE(i,x,key.substr(i,1)));
            q.push(tree[i]);
        }
        buildTree();
        cin>>n;
        cin.get();
        while(n--)
        {
            getline(cin,trans);
            for(int i=0;i<trans.size();i++)
            {
                int tmp=hexa[trans[i]];
                int k=8;
                for(int j=0;j<4;j++)
                {
                    binary.push(tmp/k);
                    tmp%=k;
                    k>>=1;
                }
            }
            while(!binary.empty())
            {
                toOrigin(head);
            }
            cout<<endl;
        }
        tree.clear();
    }
}

GOTOTHEBAD
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈夫曼编码 文件压缩
11-06
挺不错的,用VS2005实习的哈夫曼编码文件压缩.. 有需要的，可以拿去参考
算法学习（十）——赫夫曼编码用于数据压缩
North_City_的博客
08-19 453
目录定长编码&变长编码赫夫曼编码介绍概念介绍实现流程代码实现 定长编码&变长编码 定长编码 变长编码 赫夫曼编码介绍 概念介绍 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)， 又称霍夫曼编码， 是一种编码方式, 属于一种程序算法 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。 赫夫曼编码广泛地用于数据文件压缩。 其压缩率通常在 20%～90%之间 赫夫曼码是可变字长编码(VLC)的一种。 Huffman 于 1952 年提出一种编码方法， 称之为最佳编码。 实
基于哈夫曼编码的图像压缩算法实现
qq_60737285的博客
07-05 2373
哈夫曼编码是一种常用的压缩编码算法,采用变长码编码,属于无损压缩算法的一种，它可以将一组符号编码成对应的二进制编码，使得编码后的数据具有最短的码长，也叫霍夫曼编码。在图像压缩中，哈夫曼编码可以被用来表示像素信息，从而实现对图像的压缩。 具体来说，哈夫曼编码的基本思路是将出现频率较高的符号用较短的编码表示，而出现频率较低的符号则用较长的编码表示。对于图像数据，我们可以将出现频率较高的像素值编码为较短的码字，而对于出现频率较低的像素值，则编码为较长的码字。
数据结构------哈夫曼编码
最新发布
Z_hang_JJ的博客
02-12 1051
全网最细节Huffman树和Huffman编码的教学!!!!
哈夫曼编码的一个实际应用（压缩）
izhengtl2021的博客
07-07 2403
在课堂上，我们学习了哈夫曼编码的原理和实现方法，上实验课时也动手实现过，后来我们又追加介绍了哈夫曼编码的实际压缩和解压缩的实现方法，并且在课堂上也演示了，但当时我们却忽略了一个环节，那就是实际文件存储时，二进制是比特位，而存储的单位一般是字节，显示时又是按照十六进制的。现在给你一个由字典里的字符组成的原文，用哈夫曼方法把该原文压缩成十六进制码。 Input 本问题有多组测试数据，第一行就是测试数据...
C语言实现哈夫曼编码压缩和解压各种文件
11-19
实验目的：理解哈弗曼信源编码算法，并能应用于文件压缩中。 实验内容：写出程序，利用哈弗曼编码实现对文件的压缩，并能解压文件。 实验步骤： 1、压缩 （1） 统计原始文件中各字节出现的概率（次数）； （2） 采用...
基于哈夫曼编码的文本文件压缩与解压缩.zip
07-02
哈夫曼编码进行文本压缩
哈夫曼编码压缩解压.rar
03-13
专业实践，使用哈夫曼编码进行压缩解压
哈夫曼编码压缩和解压缩文件——C++实现
01-20
经验证解压缩前与解压缩后文本一致，无出入 文件目录 binaryTreeNode.h linkedBinaryTree.h 源.cpp 代码如下 binaryTreeNode.h #ifndef binaryTreeNode_ #define binaryTreeNode_ #include #include #include ...
Java哈夫曼编码的文件的压缩与解压.docx
07-02
//根据编码扫描到对应的ASCLL码对应的字符 List<Byte> list = new ArrayList(); for (int i = 0; i (); ) { int count = 1; boolean flag = true; Byte b = null; while (flag) { String key = stringBuilder...
哈夫曼编码的一个实际应用
izhengtl2021的博客
07-07 5345
在课堂上，我们学习了哈夫曼编码的原理和实现方法，上实验课时也动手实现过，后来我们又追加介绍了哈夫曼编码的实际压缩和解压缩的实现方法，并且在课堂上也演示了，但当时我们却忽略了一个环节，那就是实际文件存储时，二进制是比特位，而存储的单位一般是字节，显示时又是按照十六进制的。现在给你一个已经用哈夫曼方法压缩过的十六进制文件，请你解压以便还原成原文。 Input 本问题有多组测试数据，第一行就是测试数据的...
基于哈夫曼编码的文本文件压缩与解压缩
热门推荐
BENULL的博客
10-30 2万+
基于哈夫曼编码实现文件压缩与解压缩,采用哈夫曼静态编码的方式，通过对数据进行两遍扫描，第一次统计出现的字符频次，进而构造哈夫曼树，第二遍扫描数据根据得到的哈夫曼树对数据进行编码。对于其中的加密编码只是简单的将用户输入的密码用特殊的标识位拼接成字符串加入需要统计的数据。
一个哈夫曼编码的有趣使用
lovego123的博客
05-04 2141
哈夫曼编码是基于哈夫曼树的一种长度最短的前缀编码。这里，我不详细讲哈夫曼树与哈夫曼编码的相关知识，说一下自己在学习过程中的一点想法。我们看影视剧会经常会看到一方给另一方发送了一大串“01”混合的数串，而另一方会根据某种预先设定好的编码表来解密这一串“01”的奥义，这就是哈夫曼编码的使用之一。至此，我们就会想可以自己设定一串“01”串，这个串中隐含了你想说给他（她）的话，这样通过你喜欢的方式将串传递...
C++实现哈夫曼编码--使用哈夫曼编码树压缩和解压缩
faithzzf的专栏
01-04 1万+
静态哈夫曼编码的C++实现--使用哈夫曼编码树压缩和解压缩。
哈夫曼编码应用之实现文件压缩
no_sying_nothing的博客
07-30 3812
背景：为了锻炼自己的代码能力，以及数据结构算法掌握的能力，做此项目来锻炼自己提高自己的能力，本项目运用了C++中的知识，比如模板类，仿函数等等，还用到了数据结构中的算法知识，比如建堆调堆、哈夫曼编码，还用到了文件操作的知识。总是试一次很好的训练。
哈夫曼编码与压缩效率分析
taoyuanxiao的博客
07-09 1万+
一、实验原理  1、本实验中Huffman编码算法  (1)将文件以ASCII字符流的形式读入，统计每个符号的发生频率;  (2)将所有文件中出现过的字符按照频率从小到大的顺序排列;  (3)每一次选出最小的两个值，作为二叉树的两个叶子节点，将和作为它们的根节点，这两个叶子节点不再参与比较，新的根节点参与比较;  (4)重复3，直到最后得到和为1的根节点;  (5)将形成的二叉树的左节
贪心算法题解（哈夫曼编码专题）
ZY的博客
11-18 1620
A. 哈夫曼编码问题 Description 给定一个数字N，代表有N种不同的字符，已知每种字符的出现次数，现在要求你设计一种编码，使得任意一个编码都不是另外一个编码的前缀，并且使得这些字符经过编码压缩之后的总长度最小； Input 一个数字N 代表有多少种不同的字符(0<=N<=1000) ​ N个数字 每个数字代表一种字符的出现次数 Output 一个数字，代表总的编码长度 Sample Input 5 1 2 3 4 5 3 3 8 8 Sample Output 33 30 Ans
哈夫曼编码一段字符串压缩解压
01-15
哈夫曼编码是一种用于数据压缩的算法，它通过将出现频率较高的字符用较短的编码表示，从而实现对数据的压缩。下面是使用Python实现哈夫曼编码和解码的示例代码： ```python import heapq from collections import defaultdict # 构建哈夫曼树 def build_huffman_tree(freq): heap = [[weight, [char, ""]] for char, weight in freq.items()] heapq.heapify(heap) while len(heap) > 1: lo = heapq.heappop(heap) hi = heapq.heappop(heap) for pair in lo[1:]: pair[1] = '0' + pair[1] for pair in hi[1:]: pair[1] = '1' + pair[1] heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:]) return heap[0] # 生成哈夫曼编码表 def generate_huffman_code(tree): huffman_code = {} for pair in tree[1:]: char = pair[0] code = pair[1] huffman_code[char] = code return huffman_code # 压缩字符串 def compress_string(string, huffman_code): compressed_string = "" for char in string: compressed_string += huffman_code[char] return compressed_string # 解压字符串 def decompress_string(compressed_string, huffman_code): decompressed_string = "" code = "" for bit in compressed_string: code += bit for char, c in huffman_code.items(): if code == c: decompressed_string += char code = "" break return decompressed_string # 示例 string = "hello world" freq = defaultdict(int) for char in string: freq[char] += 1 tree = build_huffman_tree(freq) huffman_code = generate_huffman_code(tree) compressed_string = compress_string(string, huffman_code) decompressed_string = decompress_string(compressed_string, huffman_code) print("原始字符串:", string) print("压缩后的字符串:", compressed_string) print("解压后的字符串:", decompressed_string) ``` 运行以上代码，将输出以下结果： ``` 原始字符串: hello world 压缩后的字符串: 0110111011110010111001100 解压后的字符串: hello world ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值