数据结构-哈夫曼树

一．实验目的和要求：

通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在实际问题中的应用。此实验可以作为综合实验，阶段性实验时可以选择其中的几个功能来设计和实现。二．主要内容：

题目：哈夫曼编码/译码

问题描述：

利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发编写一个哈夫曼码的编/译码系统。

基本要求：

（1）接收原始数据：从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmtree.dat中。

（2）编码：利用已建好的哈夫曼树（如不在内存，则从文件hfmtree.dat中读入），对文件中的正文进行编码，然后将结果存入文件codefile.dat中。

（3）译码：利用已建好的哈夫曼树将文件codefile.dat中的代码进行译码，结果存入文件textfile.dat中。

（4）打印编码规则：即字符与编码的一一对应关系。

（5）打印哈夫曼树：将已在内存中的哈夫曼树以直观的方式显示在终端上。

测试数据：

（1）利用教科书中的数据调试程序。

（2）用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FA VORITE”。

字符 A B C D E F G H I J K L M 频度186 64 13 22 32 103 21 15 47 57 1 5 32 20 字符N O P Q R S T U V W X Y Z

频度57 63 15 1 48 51 80 23 8 18 1 16 1

选作内容：

（1）上述CodeFile的基类型实际上可能占用了存放一个整数的空间，只起到示意或模拟的作用。现使CodeFile的基类型package＝integer，把哈夫曼码紧缩到一个整形变量中去，最大限度地利用码点存储能力，试改写你的系统。

（2）修改你的系统，实际对你的系统的原程序的编码和译码（主要是将行尾符编/译码问题）。

（3）实现各个转换操作的源/目文件，均由用户在选择此操作时指定。

三. 实验方案（程序设计说明）

（一）算法设计思路

2.根据建立好的哈夫曼树对叶结点进行编码；

3.输入字符串，与叶结点字符一一对应，输出对应的字符与其编码。（二）流程图

（三）界面设计说明

哈夫曼树建立成功

编码成功

输入字符串

字符与对应的编码

（四）使用模块及变量的说明

HNodeType 结构体存放字符的权值，左孩子，右孩子及父结点

HNodeType HFMTree[] 结构体建立哈夫曼树

HCodeType 结构体栈

HCodeType HuffCode[MAXLEAF] 栈存放编码

char a[MAXLEAF] 存放要编译的字符串

四. 实验步骤或程序（经调试后正确的源程序）

#include "stdafx.h"

#include "conio.h"

#include "iostream"

#include "vector"

#include "string"

#include

using namespace std;

#define MAXWEIGHT 1000

#define MAXLEAF 27

#define MAXJIEDIAN 2*MAXLEAF-1

#define YEJIEDIAN 10

#define N 30

ifstream infile;

ofstream outfile;

char Codes[MAXLEAF] = { '

','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W' ,'X','Y','Z' };

int Weight[MAXLEAF] = { 186,64,13,22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1 };

typedef struct

{

char code;

int weight;

int parent;

int lchild;

int rchild;

}HNodeType;

typedef struct

{

int code[YEJIEDIAN];

int top;

int start;

}HCodeType;

void CreatTree(HNodeType HFMTree[]) //构造一棵哈夫曼树

{

int m1, m2, x1, x2;

int i, j = 0;

for (i = 0; i

{

HFMTree[i].code = Codes[i];

HFMTree[i].weight = Weight[i];

HFMTree[i].parent = -1;

HFMTree[i].lchild = -1;

HFMTree[i].rchild = -1;

}

for (i = 0; i

{

x1 = x2 = MAXWEIGHT;

m1 = m2 = 0;

for (j = 0; j

{

if (HFMTree[j].parent == -1 && HFMTree[j].weight

{

x2 = x1; m2 = m1;

x1 = HFMTree[j].weight; m1 = j;

}

else

if (HFMTree[j].parent == -1 && HFMTree[j].weight

{

x2 = HFMTree[j].weight;

m2 = j;

}

}

HFMTree[m1].parent = MAXLEAF + i; HFMTree[m2].parent = MAXLEAF + i;

HFMTree[MAXLEAF + i].weight = HFMTree[m1].weight + HFMTree[m2].weight;

HFMTree[MAXLEAF + i].lchild = m1; HFMTree[MAXLEAF + i].rchild = m2;

HFMTree[MAXLEAF + i].code = '*';

}

outfile.open("d:\\hfmtree.txt");

outfile << "序号" << '\t' << "字符" << '\t' << "权值" << '\t' << "左孩子" << '\t' << "右孩子" << '\t' << "父结点" << endl;

for (int i = 0; i < MAXJIEDIAN; i++)

{

outfile << i << '\t' << HFMTree[i].code << '\t' << HFMTree[i].weight << '\t';

outfile << HFMTree[i].lchild << '\t' << HFMTree[i].rchild << '\t' << HFMTree[i].parent << endl;

}

outfile.close();

cerr << "哈夫曼树建立完成!" << endl;

}

void Code1(HNodeType HFMTree[], HCodeType HuffCode[]) {

int i, c, p;

outfile.open("d:\\codefile.txt");

for (i = 0; i < MAXLEAF; i++)

{

HCodeType *cd = new HCodeType;

cd->top = -1;

c = i;

p = HFMTree[c].parent;

while (p != -1)

{

cd->top++;

if (HFMTree[p].lchild == c)

cd->code[cd->top] = 0;

else

cd->code[cd->top] = 1;

c = p;

p = HFMTree[c].parent;

}

int n = cd->top;

int k = 0;

while (k <= n&&cd->top > -1)

{

HuffCode[i].code[k] = cd->code[cd->top];

k++;

cd->top--;

}

HuffCode[i].top = n;

HuffCode[i].start = MAXLEAF - HuffCode[i].top;

outfile << HFMTree[i].code << '\t';

for (int j = 0; j <= n; j++)

outfile << HuffCode[i].code[j];

outfile << endl;

}

outfile.close();

cerr << "编码成功!" << endl;

}

void Translate(HNodeType HFMTree[], HCodeType HuffCode[]) {

int i, j;

char a[N];

cerr << "请输入字符串(大写):" << endl;

cin.get(a, N);

for (i = 0; i

{

for (j = 0; j

{

if (HFMTree[j].code == a[i])

{

cerr << a[i] << '\t';

for (int k = 0; k <= HuffCode[j].top; k++)

cerr << HuffCode[j].code[k];

cerr << endl;

break;

}

}

}

cerr << "翻译完成!" << endl;

}

/*

void Reranslate(HNodeType HFMTree[], HCodeType HuffCode[]) {

int j = 0,n;

cerr << "请输入将要翻译的编码的个数" << endl;

cin >> n;

vector b(n);

cerr << "请输入将要翻译的编码(数与数之间用空格或换行符隔开)" << endl;

for (int w = 0; w

cin >> b[w];

for(int l=0;l

{

for(int i=0;i

{

for(int k=0;b[k+j];k++)

{

if(HuffCode[i].start+k==MAXLEAF)

{

cout<

j+=k;

i=MAXLEAF;

break;

}

if(HuffCode[i].code[HuffCode[i].start+k]!=b[k+j])

break;

}

}

}

cerr << "译码完成!" << endl;

}*/

void Reranslate(HNodeType HFMTree[], HCodeType HuffCode[])

{

int i = 0, j = 0, m = 0, n, flag = 0, temp = 0;

cerr << "请输入将要翻译的编码的个数" << endl;

cin >> n;

vector b(n);

cerr << "请输入将要翻译的编码(数与数之间用空格或换行符隔开)" << endl;

for (int w = 0; w

cin >> b[w];

for (int k = 0; k

{

if (HuffCode[j].code[flag] != b[i])

{

flag = 0; i = temp; j++; k = 0; continue;

}

while (HuffCode[j].code[flag] == b[i])

{

if (flag

{

i++; flag++; continue;

}

if (flag>HuffCode[j].top || i>n - 1)

{

i = temp; flag = 0; j++; k = 0; continue;

}

if (flag == HuffCode[j].top&&HuffCode[j].start + flag == MAXLEAF)

{

cout << "对应字符为" << HFMTree[j].code << endl;

temp = i + 1;

i++;

k = 0;

flag = 0;

j = 0;

if (i > n - 1)

{

k = YEJIEDIAN;

break;

}

}

}

}

cout << "译码完成!" << endl;

}

void main()

{

int i;

HNodeType HFMTree[MAXJIEDIAN];

CreatTree(HFMTree);

HCodeType HuffCode[MAXLEAF];

for (i = 0; i

HuffCode[i].top = -1;

Code1(HFMTree, HuffCode);

Translate(HFMTree, HuffCode);

Reranslate(HFMTree, HuffCode);

_getch();

}

五．程序运行结果

哈夫曼树建立

字符译码：

字符编码结果：

编码翻译结果：

六．实验总结

哈夫曼树的建立让我对哈夫曼树有了更深的理解，用栈存放编码；字符译为编码相对于编码译为字符较容易。编码译为字符的过程要把各种情况考虑全面。难点在于当第一个字符翻译出来时，如何进行后续字符的翻译。通过此次实验，对哈夫曼树掌握更多，也学到了不少的编程知识与技巧。