北邮信通院数据结构实验报告三哈夫曼编码器
数据结构实验实验报告Huffman赫夫曼编码及应用
实验报告课程名称：数据结构实验名称：赫夫曼编码及应用院（系）：计算机与通信工程学院专业班级：计算机科学与技术姓名：学号：指导教师：2020 年 5 月12 日一、实验目的掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。
二、实验内容及要求1、任务描述a.提取原始文件中的数据（包括中文、英文或其他字符），根据数据出现的频率为权重，b.构建Huffman编码表；c.根据Huffman编码表对原始文件进行加密，得到加密文件并保存到硬盘上；d.将加密文件进行解密，得到解码文件并保存点硬盘上；e.比对原始文件和解码文件的一致性，得出是否一致的结论。
2、主要数据类型与变量a.对Huffman树采用双亲孩子表示法，便于在加密与解密时的操作。
typedef struct Huffman* HuffmanTree;struct Huffman{unsigned int weight; //权值unsigned int p, l, r;//双亲，左右孩子};b．对文本中出现的所有字符用链表进行存储。
typedef struct statistics* List;struct statistics {char str; //存储此字符int Frequency; //出现的频率（次数）string FinalNum; //Huffman编码struct statistics* Next;};3、算法或程序模块对读取到的文本进行逐字符遍历，统计每个字符出现的次数，并记录在创建的链表中。
借助Huffman树结构，生成结构数组，先存储在文本中出现的所有字符以及它们出现的频率（即权值），当作树的叶子节点。
再根据叶子节点生成它们的双亲节点，同样存入Huffman树中。
在完成对Huffman树的创建与存储之后，根据树节点的双亲节点域以及孩子节点域，生成每个字符的Huffman编码，并存入该字符所在链表节点的FinalNum域。
北邮信通院数据结构实验报告三哈夫曼编码器.pptx
-1
2.2 关键算法分析 （1）计算出现字符的权值
利用 ASCII 码统计出现字符的次数，再将未出现的字符进行筛选，将出现的字符及頻 数存储在数组 a[]中。
void Huffman::Init() {
int nNum[256]= {0}; //记录每一个字符出现的次数 int ch = cin.get();
第2页
北京邮电大学信息与通信工程学 院
2
-1
-1
-1
5
-1
-1
-1
6
-1
-1
-1
7
-1
-1
-1
9
-1
-1
-1
weight lchild rchild parent
2
-1
-1
5
5
-1
-1
5
6
-1
-1
6
7
-1
-1
6
9
-1
-1
7
7
0
1
7
第3页
北京邮电大学信息与通信工程学 院
13
2
3
8
16
5
4
8
29
6
7
2、建立编码表(CreateTable)：利用已经建好的赫夫曼树进行编码，并将每 个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的 字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译 码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作） 6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告一、实验目的：通过哈夫曼编、译码算法的实现，巩固二叉树及哈夫曼树相关知识的理解掌握，训练学生运用所学知识，解决实际问题的能力。
二、实验内容：已知每一个字符出现的频率，构造哈夫曼树，并设计哈夫曼编码。
1、从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树。
2、打印每一个字符对应的哈夫曼编码。
3、对从终端读入的字符串进行编码，并显示编码结果。
4、对从终端读入的编码串进行译码，并显示译码结果。
三、实验方案设计：（对基本数据类型定义要有注释说明，解决问题的算法思想描述要完整，算法结构和程序功能模块之间的逻辑调用关系要清晰，关键算法要有相应的流程图，对算法的时间复杂度要进行分析）1、算法思想：（1）构造两个结构体分别存储结点的字符及权值、哈夫曼编码值：（2）读取前n个结点的字符及权值，建立哈夫曼树：（3）根据哈夫曼树求出哈夫曼编码：2、算法时间复杂度：（1）建立哈夫曼树时进行n到1次合并，产生n到1个新结点，并选出两个权值最小的根结点：O（n²）；（2）根据哈夫曼树求出哈夫曼编码：O（n²）。
（3）读入电文，根据哈夫曼树译码：O（n）。
四、该程序的功能和运行结果：（至少有三种不同的测试数据和相应的运行结果，充分体现该程序的鲁棒性）1、输入字符A，B，C，D，E，F及其相应权值16、12、9、30、6、3。
2、输入字符F，E，N，G，H，U，I及其相应权值30、12、23、22、12、7、9。
3、输入字符A，B，C，D，E，F，G，H，I，G及其相应权值19、23、25、18、12、67、23、9、32、33。
北邮数据结构实验3哈夫曼编码
数据结构实验报告实验名称：实验3——哈夫曼编码学生姓名：班级：班内序号：学号：日期：2013年11月24日1．实验要求利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化(Init)：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表(CreateTable)：利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
2. 程序分析2.1存储结构：struct HNode{char c;//存字符内容int weight;int lchild, rchild, parent;};struct HCode{char data;char code[100];}; //字符及其编码结构class Huffman{private:HNode* huffTree; //Huffman树HCode* HCodeTable; //Huffman编码表public:Huffman(void);void CreateHTree(int a[], int n); //创建huffman树void CreateCodeTable(char b[], int n); //创建编码表void Encode(char *s, string *d); //编码void Decode(char *s, char *d); //解码void differ(char *,int n);char str2[100];//数组中不同的字符组成的串int dif;//str2[]的大小~Huffman(void);};结点结构为如下所示：三叉树的节点结构：struct HNode//哈夫曼树结点的结构体{ int weight;//结点权值int parent;//双亲指针int lchild;//左孩子指针int rchild;//右孩子指针char data;//字符};示意图为：int weight int parent int lchild int rchild Char c 编码表节点结构：struct HCode//编码表结构体{char data;//字符char code[100];//编码内容};示意图为：基本结构体记录字符和出现次数:struct node{int num;char data;};示意图为:2.关键算法分析(1).初始化:伪代码：1.输入需要编译的文本内容2.将输入的内容保存到数组str1中3.统计出现的字符数目,并且保存到变量count中4.统计出现的不同的字符，存到str2中，将str2的大小存到dif中时间复杂度O(n！)（2）.创建哈夫曼树算法伪代码：1.创建一个长度为2*n-1的三叉链表2.将存储字符及其权值的链表中的字符逐个写入三叉链表的前n个结点的data域，并将对应结点的孩子域和双亲域赋为空3.从三叉链表的第n个结点开始，3.1从存储字符及其权值的链表中取出两个权值最小的结点x,y，记录其下标x,y。
数据结构 哈夫曼编码实验报告
数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1. 实验目的本实验旨在通过实践理解哈夫曼编码的原理和实现方法，加深对数据结构中树的理解，并掌握使用Python编写哈夫曼编码的能力。
2. 实验原理哈夫曼编码是一种用于无损数据压缩的算法，通过根据字符出现的频率构建一棵哈夫曼树，并根据哈夫曼树对应的编码。
根据哈夫曼树的特性，频率较低的字符具有较长的编码，而频率较高的字符具有较短的编码，从而实现了对数据的有效压缩。
实现哈夫曼编码的主要步骤如下：1. 统计输入文本中每个字符的频率。
2. 根据字符频率构建哈夫曼树，其中树的叶子节点代表字符，内部节点代表字符频率的累加。
3. 遍历哈夫曼树，根据左右子树的关系对应的哈夫曼编码。
4. 使用的哈夫曼编码对输入文本进行编码。
5. 将编码后的二进制数据保存到文件，同时保存用于解码的哈夫曼树结构。
6. 对编码后的文件进行解码，还原原始文本。
3. 实验过程3.1 统计字符频率首先，我们需要统计输入文本中每个字符出现的频率。
可以使用Python中的字典数据结构来记录字符频率。
遍历输入文本的每个字符，将字符添加到字典中，并递增相应字符频率的计数。
```pythondef count_frequency(text):frequency = {}for char in text:if char in frequency:frequency[char] += 1else:frequency[char] = 1return frequency```3.2 构建哈夫曼树根据字符频率构建哈夫曼树是哈夫曼编码的核心步骤。
我们可以使用最小堆（优先队列）来高效地构建哈夫曼树。
首先，将每个字符频率作为节点存储到最小堆中。
然后，从最小堆中取出频率最小的两个节点，将它们作为子树构建成一个新的节点，新节点的频率等于两个子节点频率的和。
将新节点重新插入最小堆，并重复该过程，直到最小堆中只剩下一个节点，即哈夫曼树的根节点。
北邮数据结构实验哈夫曼编码解码
#include<iostream>
#include<string>
using namespace std;
const int NUM=128;
const int M=1000;
int frequency[NUM]={0}; //统计各输入字符频率
void Huffman::CteatCodeTable(char letters[],int frequency[]) //生成编码表
{
Hcodetable=new Hcode[leaf];
for(int i=0,m=0;i<128;i++)
{
if(frequency[i]!=0)
temp[i]=HTree[i].weight;
HTree[i].Lchild=Min1;
HTree[i].Rchild=Min2;
HTree[i].parent=-1;
}
delete temp;
}
///////////////////////////////////////////////////////////////////////////////////////////
void Encode(char *s,char*d); //编码函数
void Decode(char *s,char*d); //解码函数
void Reverse(char a[]); //编码倒置函数
void Huffman::Reverse(char a[])
{
int m=0;
while(a[m]!='\0')
北邮数据结构实验报告三题目2-哈夫曼树
11．实验要求利用二叉树结构实现哈夫曼编/ 解码器(1). 初始化：能够对输入的任意长度的字符串s 进行统计，统计每个字符的频度，并建立哈夫曼树。
(2). 建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
(3). 编码：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
(4). 译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
(5). 打印：以直观的方式打印哈夫曼树。
(6). 计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。
(7). 用户界面可以设计成“菜单”方式，能进行交互，根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2.程序分析2.1存储结构二叉树：示意图：root2.21{2.3 关键算法分析1. 定义哈夫曼树的模板类#include <iostream>#include <string.h> using namespace std; structLNode {char ch;int weight;char code[20];LNode* next; };struct TNode{int weight; //int Lchild; //int Rchild; //int Parent; // };class Huffman 结点权值左孩子指针右孩子指针双亲指针// 链表的节点, 用来统计字符频率，并编码// 字符// 权值// 字符编码// 指向下一个节点// 哈弗曼树结点的结构体1 public:Huffman(); ~Huffman(); void CreateTable(); void PrintTable(); void Encoding(); void Decoding(); void Comrate();// 构造函数，输入、统计字符，创建哈弗曼树、码表// 释放链表空间、哈弗曼树的节点// 建立编码表，并将信息存入链表// 输出码表// 哈弗曼编码// 译码void SelectMin(int &x,int &y,int begin,int end);void reverse(char ch[]); voidcontrol();private: // 选取权值最小的两个数，创建哈弗曼树// 将码值倒置，用来编码// 对菜单交互等提示操作TNode* troot;LNode* lroot; void List(char a[]); void HTree(); int Letter; char astr[1000]; char bstr[1000]; // 在统计字符频率是构建链表的根节点// 统计字符的权值建立的单链表// 哈弗曼树建立// 共有不同字符总数// 用户输入的一串字符// 将字符串的码值保存Huffman::Huffman(){lroot=new LNode;bstr[0]='\0';lroot->next=NULL;Letter=0; // 初始化字符总数为1 cout<<" 请输入一串字符，以回车键结束"<<endl;cin.getline(astr,1000,'\n');if(strlen(astr)==0) throw 1;else{List(astr); // 用链表存储每个字符HTree();CreateTable();Encoding();}};Huffman::~Huffman(){delete troot;LNode* p=lroot;while(p=lroot->next)1{{ lroot=p->next; delete p; p=lroot;}delete p; };2. 建立哈夫曼树void Huffman::HTree(){LNode* p=lroot; int a=0;troot=new TNode[2*Letter-1]; //2n-1 while (p=p->next){troot[a].weight=p->weight; troot[a].Parent=-1; troot[a].Lchild=-1; troot[a].Rchild=-1; a++;};for (int i=Letter;i<2*Letter-1;i++)troot[i].Parent=-1; int x,y,begin=0;for (int j=Letter;j<2*Letter-1;j++) while (troot[begin].Parent!=-1)begin++;个结点// 建立叶子节点// 是两个最小值的角标SelectMin(x,y,begin,j);troot[j].weight=troot[x].weight+troot[y].weight;troot[j].Lchild=x;troot[j].Rchild=y;troot[j].Parent=-1;troot[x].Parent=j;troot[y].Parent=j;}};3.统计字符的频率void Huffman::List(char a[]){LNode *p=lroot;int i=0;while(a[i]!='\0'){{while (p&&p->ch!=a[i]) // 查找链表中没有该字符或者找到该字符p=p->next;if (!p) // 如果没有该字符，创建节点。
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告【正文】1.实验目的本实验旨在研究哈夫曼编码的原理和实现方法，通过实验验证哈夫曼编码在数据压缩中的有效性，并分析其应用场景和优缺点。
2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法，通过根据字符出现的频率构建一颗哈夫曼树，将频率较高的字符用较短的编码表示，频率较低的字符用较长的编码表示。
哈夫曼编码的编码表是唯一的，且能够实现前缀编码，即一个编码不是另一个编码的前缀。
2.2 构建哈夫曼树构建哈夫曼树的过程如下：1) 将每个字符及其频率作为一个节点，构建一个节点集合。
2) 每次从节点集合中选择出现频率最低的两个节点，构建一个新节点，并将这两个节点从集合中删除。
3) 将新节点加入节点集合。
4) 重复以上步骤，直到节点集合中只有一个节点，这个节点就是哈夫曼树的根节点。
2.3 编码过程根据哈夫曼树，对每个字符进行编码：1) 从根节点开始，根据左子树为0，右子树为1的规则，将编码依次加入编码表。
2) 对于每个字符，根据编码表获取其编码。
3) 将编码存储起来，得到最终的编码序列。
3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列，并统计各个字符的频率。
3.2 构建哈夫曼树根据字符频率构建哈夫曼树。
3.3 构建编码表根据哈夫曼树，构建每个字符的编码表。
3.4 进行编码根据编码表，对输入的字符序列进行编码。
3.5 进行解码根据哈夫曼树，对编码后的序列进行解码。
4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值，分析压缩率。
4.2 编码效率分析测试编码过程所需时间，分析编码效率。
4.3 解码效率分析测试解码过程所需时间，分析解码效率。
4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。
5.结论通过本次实验，我们深入了解了哈夫曼编码的原理和实现方法，实践了哈夫曼编码的过程，并对其在数据压缩中的有效性进行了验证。
实验结果表明，哈夫曼编码能够实现较高的压缩率和较高的编解码效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
北京邮电大学电信工程学院数据结构实验报告实验名称：实验三树 ----- 哈夫曼编/解码器学生姓名：班级：班内序号：学号：日期：2014年12月11日1. 实验要求利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化(Init):能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表(CreateTable)利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：禾U用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print):以直观的方式打印赫夫曼树(选作)6计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
测试数据：I love data Structure, I love Computer。
I will try my best to study data Structure.提示：1、用户界面可以设计为“菜单”方式：能够进行交互。
2、根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2. 程序分析2.1存储结构Huffman 树给定一组具有确定权值的叶子结点，可以构造出不同的二叉树，其中带权路径长度最小的二叉树称为Huffman 树，也叫做最优二叉树哈夫虽树示意图root孩子双亲表示法_____________________ JL________________weight Ichild rchild pare nt数存储在数组a[]中。
void Huffma n::l nit() {int nNu m[256]= {0}; //int ch = ci n.get(); int i=0;while((ch!='\r') && (ch!='\n')) {nNu m[ch]++; // str[i++] = ch; // ch = cin .get();// str[i]='\0';n = 0;2.2关键算法分析(1)计算出现字符的权值利用ASCII 码统计出现字符的次数,再将未出现的字符进行筛选,将出现的字符及頻记录每一个字符出现的次数统计字符出现的次数记录原始字符串读取下一个字符for ( i=0;i<256;i++){if (nNum[i]>0) // 若nNum[i]==0，字符未出现{l[n] = (char)i;a[n] = nNu m[i];n++;}}}时间复杂度为0( 1);(2 )创建哈夫曼树：算法过程：Huffman树采用顺序存储---数组；数组的前n个结点存储叶子结点，然后是分支结点，最后是根结点；首先初始化叶子结点元素一循环实现；以循环结构，实现分支结点的合成，合成规则按照huffman树构成规则进行。
关键点：选择最小和次小结点合成。
void Huffma n::CreateHTree(){HTree = new HNode [2*n-1]; // 根据权重数组a[0..n-1] 初始化Huffman 树for (i nt j = 0; j < n; j++)HTree[j].weight = a[j];HTree[j].LChild = HTree[j].RChild = HTree[j].pare nt = -1;}int x,y;for (int i = n; i < 2*n-1; i++) // 开始建Huffman 树{SelectMin( HTree, i, x, y); //从1~i中选出两个权值最小的结点HTree[x].pare nt = HTree[y].pare nt = i;HTree[i].weight = HTree[x].weight+ HTree[y].weight;HTree[i].LChild = x;HTree[i].RChild = y;HTree[i].pare nt = -1;}}2时间复杂度为0(n )void Huffman::SelectMin( HNode *hTree,int n, int & 1, int &i2 ) {int i;// 找一个比较值的起始值for(i=0; i<n; i++) // 找i1{ if(hTree[i].pare nt==_1 ){ i1=i; break;}i++；for( ; i<n; i++) // 找i2{ if(hTree[i].pare nt==_1 ){ i2=i; break; }}指向最小的if(hTree[i1].weight>hTree[i2].weight) 〃i1{ int j=i2; i2=i1; i1 = j; }// 开始找最小的两个i++;for( ; i<n; i++){ if(hTree[i].pare nt==-1&& hTree[i].weight < hTree[i1].weight ) { i2=i1; i1 = i; } else if( hTree[i].pare nt==-1&& hTree[i].weight < hTree[i2].weight){ i2=i; }}}时间复杂度为0(n)(3)创建编码表child = pare nt; //迭代首先定义码表存储空间；循环对n 个叶子结点自底向上回溯到根，记下途径的左右关系, 将各个叶子结点对应的逆序串反序即可。
void Huffma n::CreateCodeTable() {HCodeTable = new HCode[ n]; // 生成编码表for (int i=0;i< n;i++)HCodeTable[i].data = l[i];int child = i;int pare nt = HTree[i].pare nt; ////孩子结点编号当前结点的父结点编号int k=0;while(pare nt!=-1)if (child==HTree[pare nt]. LChild) HCodeTable[i].code[k] = 'O'; elseHCodeTable[i].code[k] = '1 k++;算法过程：从叶子到根 自底向上形成编码的逆序串;//左孩子标//右孩子标‘ 1'pare nt = HTree[child].pare nt;child = pare nt; //迭代HCodeTable[i].code[k] = '\0：Reverse(HCodeTable[i].code);//将编码字符逆置}}时间复杂度为0(n)(4)生成编码串将输入的字符串的每一个字符与编码表比较void Huffman::Encode(char *d)〃编码，d为编码后的字符串{char *s = str;while(*s!='\0'){for (in t i=0;i< n;i++)if (*s == HCodeTable[i].data ){strcat(d, HCodeTable[i].code);break;}s++;}*d = HCodeTable[pare nt].data;时间复杂度为0(n)(5) 解码：算法过程： 从根到叶子---自顶向下基于huffman 树存储数组，从根结点开始，依据输入待解码串 s 中码字0或1，分别向左或只要s 串为结束，重复上述过程{while(*s!='\0') {{if (*s=='0')pare nt = HTree[pare nt].LChild; elsepare nt = HTree[pare nt].RChild; s++; } d++;右跟踪至叶子结点，叶子结点对应的字符(见码表)，即为解码得到的字符;void Huffma n::Decode(char* s, char *d)//解码，s 为编码串，d 为解码后的字符串int pare nt = 2*n-2;while (HTree[pare nt]. LChild!=-1) II //根结点在HTree 中的下标如果不是叶子结点}时间复杂度为0(n)2.3其他(1)哈夫曼树的输出是以凹入表示法来实现的，具体算法如下：void Huffma n::Pri nt( in t i, i nt m){if (HTree[i].LChild == -1)cout<<setfill(' ')<<setw(m+1)<<l[i]<<setfill('-')<<setw(10-m)<<'\n：else{cout<<setfill(' ')<<setw(m+1)<<HTree[i].weight<<setfill('-')<<setw(10-m)<<'\n：Prin t(HTree[i].LChild,m+1);Prin t(HTree[i].RChild,m+1);}}(2)统计字符頻数时，利用字符的ASCII码进行计数统计，调用了cin.get()函数3.程序运行程序框图：开始输入要编码的字符串*d = HCodeTable[pare nt].data;结束#in elude <iostream> #i nclude <ioma nip> using n amespace std; struct HNode {int weight; 〃结点权值int parent; //双亲指针int LChild; //左孩子指针 int RChild ; //右孩子指针};struct HCode {char data; char code[100]; };class Huffma n {private:HNode* HTree; HCode* HCodeTable; char str[1024]; char l[256]; int a[256]; public:int n;程序源代码://Huffman 树 //Huffman 编码表 //输入的原始字符串〃叶子节点对应的字符//记录每个出现的字符的个数〃叶子节点数void Ini t();void CreateHTree();void CreateCodeTable(); void Prin tTable();void En code(char *d); void Decode(char *s, char *d); void Prin t( int i,i nt m);//初始化//创建huffman树//创建编码表//编码//解码//打印Huffman树void SelectMi n( HNode *hTree, int n, int & 1, i nt & 2);// 找出最小的两个权值void Reverse(char* s); void Compare(char*d);~ Huffma n(); }; //逆序//比较压缩大小〃析构void Huffma n::l nit() {int nNum[256]= {0};int ch = cin .get();int i=0;while((ch!='\r') && (ch!='\n')) {nNu m[ch]++;str[i++] = ch;ch = cin .get(); }str[i]='\0'; //记录每一个字符出现的次数//统计字符出现的次数//记录原始字符串//读取下一个字符n = 0;for ( i=0;i<256;i++) {if (nN um[i]>0){l[n] = (char)i;a[n] = nNu m[i];n++;}}}void Huffman::CreateHTree(){HTree = new HNode [2* n-1]; 树〃若nNum[i]==0，字符未出现//根据权重数组a[0..n-1]初始化Huffmanfor (i nt j = 0; j < n; j++){HTree[j].weight = a[j];HTree[j].LChild = HTree[j].RChild = HTree[j].pare nt = -1;}int x,y;for (int i = n; i < 2*n-1; i++) 〃开始建Huffman 树{SelectMin( HTree, i, x, y); //从1~i中选出两个权值最小的结点HTree[x].pare nt = HTree[y].pare nt = i;HTree[i].weight = HTree[x].weight+ HTree[y].weight;HTree[i].LChild = x;HTree[i].RChild = y;HTree[i].pare nt = -1;}void Huffman::SelectMin( HNode *hTree,int n, {int & 1, int &i2 ) int i;//找一个比较值的起始值for(i=0; i<n; i++) // 找i1{ if(hTree[i].pare nt==_1 ){ i1=i; break; }}i++;for( ; i<n; i++) // 找i2{ if(hTree[i].pare nt==_1 ){ i2=i; break; }}if(hTree[i1].weight>hTree[i2].weight) 〃i1 指向最小的{ int j=i2; i2=i1; i1 = j; }〃开始找最小的两个i++;for( ; i<n; i++){ if(hTree[i].pare nt==_1&& hTree[i].weight < hTree[i1].weight ){ i2=i1; i1 = i; }else if( hTree[i].pare nt==-1&& hTree[i].weight < hTree[i2].weight){ i2=i; }}}void Huffma n::Pri nt( in t i, i nt m){if (HTree[i].LChild == -1)cout<<setfill(' ')<<setw(m+1)<<l[i]<<setfill('-')<<setw(10-m)<<'\n： else{cout<<setfill(' ')<<setw(m+1)<<HTree[i].weight<<setfill('-')<<setw(10-m)<<'\n：Prin t(HTree[i].LChild,m+1);Prin t(HTree[i].RChild,m+1);}}void Huffma n::CreateCodeTable(){HCodeTable = new HCode[n]; // 生成编码表for (i nt i=0;i <n ;i++){HCodeTable[i].data = l[i];int child = i; //孩子结点编号in t pare nt = HTree[i].pare nt; //当前结点的父结点编号int k=0;while(pare nt!=-1){if (child==HTree[parent].LChild) //左孩子标’O'HCodeTable[i].code[k] = '0';elseHCodeTable[i].code[k] = '1' ; // 右孩子标’1k++;child = pare nt; // 迭代pare nt = HTree[child].pare nt;}HCodeTable[i].code[k] = '\0';Reverse(HCodeTable[i].code); // 将编码字符逆置}}void Huffma n::Pri ntTable(){for (i nt i=0;i <n ;i++) cout<<HCodeTable[i].data<<'\t'<<HCodeTable[i].code<<e ndl;}void Huffman::Encode(char *d)〃编码，d为编码后的字符串{char *s = str;while(*s!='\0'){for (int i=0;i< n;i++)if (*s ==HCodeTable[i].data ){strcat(d, HCodeTable[i].code);break;}s++;}}void Huffman::Decode(char* s, char *d) 〃解码，s 为编码串，d 为解码后的字符串{while(*s!='\0'){in t pare nt = 2*n-2; 〃根结点在HTree中的下标while (HTree[pare nt]. LChild!=-1) 〃如果不是叶子结点{if (*s=='0')pare nt = HTree[pare nt].LChild;elsepare nt = HTree[pare nt].RChild;s++;}*d = HCodeTable[pare nt].data;d++;}}void Huffman::Reverse(char* s)// 换序{char ch;int len = strle n( s);for (int i=0;i<len/2;i++) {ch = s[i];s[i] = s[le n-i-1];s[le n-i-1] = ch;}}void Huffman::Compare(char*d)〃比较压缩大小{cout<<"编码前："<<strle n(str)*8<<"bit"<<e ndl;cout<<"编码后："<<strle n(d)<<"bit"<<e ndl;}Huffman::~ Huffman()// 析构函数{delete []HTree;delete []HCodeTable;}void mai n(){Huffma n HFCode;char d[1024]={0};char s[1024]={0};cout<<"请输入要编码的字符串：";HFCode.I nit();HFCode.CreateHTree();HFCode.CreateCodeTable();HFCode.E ncode(d);HFCode.Decode(d,s);int m;cout<<"欢迎使用\n"<<"1.打印哈夫曼树\n"<<"2.打印哈夫曼编码表打印编码\n"<<"3. \n"<<"4.打印解码\n"<<"5.压缩比"<<endl;while(1){cin»m;switch(m){case 1:{HFCode.Pri nt(2*HFCode. n-2,1);break;}case 2:{HFCode.Pri ntTable();break;}case 3:{cout<<"编码结果："<<d<<e ndl; break;} case 4:{cout<<"解码结果："<<s<<endl; break; } case 5:{pare(d); } } } }运行结果:*E ：\vc-b - \Microsoft Visual Stu□ i o\F/lyPrcy ects x h af u m\Debug\nafnj.e>：eI uiLl ti'y my best tLoue cl 且 I ：丑 S true cure I loue Computer^:叱* ?■片3 的st 黏 码t a 員> 编站翁筮 要y 用吟匸毎M 比」瓦LnJn r D r DI D I 5H 丿欢迎下载 214.总结在编程时，最开始在字符统计时出现了空格无法统计的问题，后来用ci n.get()函数进 行统计。