【数据结构】实验十：哈夫曼编码

实验十哈夫曼编码

一、实验目的与要求

1）掌握树、森林与二叉树的转换；

2）掌握哈夫曼树和哈夫曼编码算法的实现；

二、实验内容

1. 请编程实现如图所示的树转化为二叉树。

2. 编程实现一个哈夫曼编码系统，系统功能包括：

(1) 字符信息统计：读取待编码的源文件SourceFile.txt，统计出现的字符及其频率。

附：SourceFile.txt文件内容为

(2) 建立哈夫曼树：根据统计结果建立哈夫曼树。

(3) 建立哈夫曼码表：利用得到的哈夫曼树，将各字符对应的编码表保存在文件Code.txt中。

(4) 对源文件进行编码：根据哈夫曼码表，将SourceFile.txt中的字符转换成相应的编码文件ResultFile.txt。

实现提示：

(1) 字符信息统计：假设源文件SourceFile.txt中的字符只有大小写英文字母（同一个字母的大小写看作一个字符），则字符统计算法的实现过程可以归纳为：先定义一个含有26个元素的整形数组，用来存储各个字母出现的次数，最后还要排除其中出现次数为0的数组元素。

(2) 建立哈夫曼树：可参考教材算法。

(3) 建立哈夫曼码表：可参考教材算法。

(4) 对源文件进行编码：依次读入文件SourceFile.txt中的字符 c，在编码表 HC 中找到此字符，将字符c转换为编码表中存放的编码串，写入编码文件ResultFile.txt中，直到所有的字符处理完毕为止。

三、实验结果

1）请将调试通过的运行结果截图粘贴在下面，并说明测试用例和运行过程。

2）请将源代码cpp文件压缩上传。

题目1：

测试用例及运行结果：

测试用例输入的树为：

树通过孩子兄弟表示法转化的二叉树为：

测试用例实验结果为：

根据最后三行输出（即二叉树的先序遍历和中序遍历，以及树的层序遍历）可知，输入的树可以转化为二叉树，且存储效果均良好。

运行过程：

首先通过主函数调用的函数顺序可知，运行过程为初始化树->通过输入创建树->preorder输出树->midorder输出树->floororder输出树->销毁树。

初始化树时，不需要做额外操作。

通过输入创建树时，主要使用队列实现。首先初始化每个结点的左孩子和右兄弟均为空，然后把当前结点加入队列。如果当前结点为根结点，则树从当前结点开始。否则，获取队列的队首结点，依次存储其左孩子和右兄弟。

preorder输出树时，通过if条件判断当前结点是否为空，然后采用根结点——左孩子——右兄弟的方法递归输出。

midorder输出树时，通过if条件判断当前结点是否为空，然后采用左孩子——根结点——右兄弟的方法递归输出。

floororder输出树时，主要通过队列输出。通过if条件判断当前结点是否为空，输出当前根结点的值，然后进行根结点排队。当队列非空时，先输出根结点e的左孩子p，再输出p的右兄弟，此时容易知道p和p的右兄弟在同一层。

销毁树时，通过if条件判断当前结点是否为空，然后采用左孩子——右兄弟——根结点的方法递归销毁，并依次将结点置为空。

实验代码：

//孩子兄弟表示法存储 
#include <iostream>
#include <cstdio>
#include <malloc.h>
using namespace std;
typedef int ElemType;

typedef struct CSNode{
	ElemType data;
	struct CSNode *firstchild,*rightsib;
}CSNode,*CSTree;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct QNode{
	CSTree data;
	struct QNode *next; 
}QNode;

typedef struct LinkQueue{
	QNode *front,*rear;
}LinkQueue;

//构造空队列 
void InitQueue_Sq(LinkQueue &Q){
	Q.front = Q.rear = NULL;
}

//判断是否为空 
int QueueEmpty(const LinkQueue &Q){
	return (Q.rear == NULL && Q.front == NULL); 
}

//插入元素进队尾
void EnQueue_Sq(LinkQueue &Q,CSTree &e){
	QNode *p=(QNode*)malloc(sizeof(QNode));
	if(!p){
		exit(0);
	}
	p->data =e;
	p->next =NULL;
	if (QueueEmpty(Q)){
		Q.front =Q.rear =p;
	}
	else{
		Q.rear->next =p;
		Q.rear=p;
	}
} 


//删除元素从队头
CSTree DeQueue_Sq(LinkQueue &Q,CSTree &s){
	if(QueueEmpty(Q)){
		return ERROR;
	}
	QNode *p=Q.front ;
	s=p->data;//队头存的数据 
	if(Q.front==Q.rear){
		Q.front=Q.rear=NULL;
	}
	else{
		Q.front =p->next;
	}
	free(p);
	return s;
} 

//取队头元素
void GetHead_Sq(LinkQueue Q,CSTree &p){
	if(QueueEmpty(Q)){
		exit(0);
	}
	p=Q.front->data ;
} 

//初始化树
void InitTree_CST(CSTree &T){
	
} 

//构造树 
void CreateTree_CST(CSTree &T){
	T=NULL;
	LinkQueue Q;
	InitQueue_Sq(Q);
	ElemType parent,child;
	CSTree p,q,r=new CSNode;
	for(cin>>parent>>child;child!=0;cin>>parent>>child){
		p=(CSTree)malloc(sizeof(CSNode));
		p->data=child;
		p->firstchild =p->rightsib =NULL;
		EnQueue_Sq(Q,p);//append p to Q
		if(parent==-1){
			T=p;//root node
		}
		else{
			GetHead_Sq(Q,q);
			while(q->data != parent){
				DeQueue_Sq(Q,q);
				GetHead_Sq(Q,q);
			}
			if(!(q->firstchild )){
				q->firstchild =p;
				r=p;
			}
			else{
				r->rightsib =p;
				r=p;
			}
		}
	} 
}

//pre-order output
void PreOrderTraverse_CST(CSTree &T){
	if(T){
		cout<<T->data<<" ";
		PreOrderTraverse_CST(T->firstchild );
		PreOrderTraverse_CST(T->rightsib );
	}
}

//mid-order output
void MidOrderTraverse_CST(CSTree &T){
	if(T){
		MidOrderTraverse_CST(T->firstchild );
		cout<<T->data<<" ";
		MidOrderTraverse_CST(T->rightsib );
	}
}

//layer-order output
void FloorTraverse_CST(CSTree &T){
	LinkQueue Q;
	InitQueue_Sq(Q);
	if(T){
		cout<<T->data <<" ";
		EnQueue_Sq(Q,T);//根结点排队
		while(!QueueEmpty(Q)){
			CSTree e,p;
			e=(CSTree)malloc(sizeof(CSNode));
			p=(CSTree)malloc(sizeof(CSNode));
			DeQueue_Sq(Q,e);
			p=e->firstchild ;
			while(p){
				cout<<p->data<<" ";
				EnQueue_Sq(Q,p);
				p=p->rightsib ;
			}
		} 
	}
}

//销毁CST
void DestroyTree_CST(CSTree &T){
	if(T){
		DestroyTree_CST(T->firstchild );
		DestroyTree_CST(T->rightsib );
		free(T);
		T=NULL;
	}
} 

//主函数 
int main(){
	CSTree T;
	InitTree_CST(T);
	cout<<"Input tree:"<<endl;
	CreateTree_CST(T);
	cout<<endl<<"Preordered sequence: ";
	PreOrderTraverse_CST(T);
	cout<<endl<<"Midordered sequence: ";
	MidOrderTraverse_CST(T);
	cout<<"Floorordered sequence: ";
	FloorTraverse_CST(T);
	cout<<endl;
	DestroyTree_CST(T);
	return 0;
}

题目2

测试用例及运行结果：

测试用例1：AAABBC

运行结果截图：

SourceFile.txt内容：

Code.txt内容：

ResultFile.txt内容：

测试用例2：U ARE THE BEST IN MY HEART