数据结构与算法分析综合实验:用哈夫曼编码实现文件压缩

用哈夫曼编码实现文件压缩实验报告

一、实验目的

	1、了解文件的概念。
	2、掌握线性链表的插入、删除等算法。
	3、掌握Huffman树的概念及构造方法。
	4、掌握二叉树的存储结构及遍历算法。
	5、利用Huffman树及Huffman编码,掌握实现文件压缩的一般原理。

二、实验环境

	微型计算机、Windows系列操作系统 、Visual C++6.0软件等。

三、实验内容

根据ASCII码文件中各ASCII字符出现的频率情况创建Huffman树,再将各字符对应的哈夫曼编码写入文件中,实现文件压缩。

四、实验结果及分析

1.概要设计
(1)构造哈夫曼树的哈夫曼算法
	构造哈夫曼树步骤:
	a.根据给定的n个权值{w1,w2……wn},构造n棵树只有根结点的二叉树,起权值为wj。
	b.在森林中选取两棵根结点权值最小和次小的树作为左右子树,构造一棵新的二叉树,置新的二叉树根结点权值为其左右子树根结点权值之和。
	c.在森林中删除这两棵树,同时将新得到的二叉树加入森林中。
	d.重复上述两步,直到只含一棵树为止,这棵树即为哈夫曼树。

算法结构如图:

(2)哈夫曼编码:数据通信用的二进制编码
		思想:根据字符出现的频率编码,使电文总长最短
		编码:根据字符出现的频率构造哈夫曼树,然后将树中结点引向其左孩子的分支标“0”,引向其右孩子的分支标“1”;每个字符的编码即为从根到每个叶子的路径上得到的0、1序列。
(3)文本编码
读取存放在文本中的字母,一对一的进行编译,将对应的编码存放在另一个文本中。
2.详细设计

(1)压缩过程图解
在这里插入图片描述(2)详细代码

#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <conio.h> 

/*哈夫曼树结构定义*/
struct head 
{ 
	unsigned char b;            /*定义一个字符*/
    long count;                 /*频率数据*/ 
    long parent,lch,rch;        /*创建哈夫曼树*/ 
    char bits[256];             /*哈夫曼结点*/ 
}header[512],tmp; 


/*压缩文件*/
void yasuo()                                 
{ 
    char filename[255],outputfile[255],buf[512]; 
    unsigned char c; 
	char wenjianming[255];
    long i,j,m,n,f; 
    long min1,pt1,flength;
	FILE *ifp,*ofp; 
	printf("请输入文件地址及文件名:"); 
    gets(filename); 
    ifp = fopen(filename,"rb");     /*打开源文件并读取*/
	while(ifp==NULL)
	{ 
		printf("打开文件时出错!\n"); 
	    printf("请重新输入文件地址及文件名:"); 
		gets(filename); 
		ifp=fopen(filename,"rb");      	
	}
	printf("请输入压缩后的文件地址和文件名及后缀:");
    gets(wenjianming);
    ofp = fopen(wenjianming,"wb");    /*创建并打开目的文件*/
	
	while(ofp==NULL)
	{
		printf("请重新输入压缩后的文件地址和文件名及后缀:");
        ofp=fopen(wenjianming,"wb");      	
	}
	flength = 0; 
    
	/*读取ifp文件*/
	while(!feof(ifp))               
    { 
        fread(&c,1,1,ifp);           /*按位读取文件*/
        header[c].count++;           /*记录文件的字符总数*/
        flength++; 
    } 
    flength = -1;                   
    header[c].count = -1;             /*读取文件结束*/
	/*构造哈弗曼树,初始结点的设置*/
	for(i=0;i<512;i++)                
    { 
        if(header[i].count != 0) 
			header[i].b = (unsigned char)i; 
        else 
			header[i].b = 0; 
		header[i].parent = -1; 
		header[i].lch = header[i].rch = -1; 
    } 
    /*按结点出现的次数排序*/
	for(i=0;i<256;i++)         
    { 
        for(j=i+1;j<256;j++) 
    	{ 
            if(header[i].count < header[j].count) 
        	{ 
                tmp=header[i]; 
                header[i] = header[j]; 
                header[j] = tmp; 
        	} 
    	} 
    } 
	/*统计不同字符的数量*/
	for(i=0;i<256;i++) 
		if(header[i].count==0) 
			break; 
    n=i; 
    m=2*n-1; 
    for(i=n;i<m;i++) 
    { 
        min1=999999999; 
        for(j=0;j<i;j++) 
    	{ 
            if(header[j].parent!=-1) 
                continue; 
            if(min1>header[j].count) 
        	{ 
                pt1=j; 
                min1=header[j].count; 
                continue; 
        	} 
    	} 
        header[i].count=header[pt1].count; 
        header[pt1].parent=i; 
        header[i].lch=pt1; 
        min1=999999999; 
        for(j=0;j<i;j++) 
    	{ 
            if(header[j].parent!=-1)
                continue; 
            if(min1>header[j].count) 
        	{ 
                pt1=j; 
                min1=header[j].count; 
                continue; 
        	} 
    	} 
        header[i].count+=header[pt1].count; 
        header[i].rch=pt1; 
        header[pt1].parent=i; 
    }
	/*构造哈夫曼树,设置字符编码*/
    for(i=0;i<n;i++) 
    { 
        f = i; 
        header[i].bits[0] = 0; 
        while(header[f].parent != -1) 
    	{ 
        	j = f; 
            f = header[f].parent; 
            if(header[f].lch==j) 
        	{ 
                j = strlen(header[i].bits); 
                memmove(header[i].bits+1,header[i].bits,j+1); 
                header[i].bits[0]='0'; 
        	} 
        	else 
        	{ 
                j=strlen(header[i].bits); 
                memmove(header[i].bits+1,header[i].bits,j+1); 
                header[i].bits[0]='1'; 
        	} 
    	} 
    } /*哈弗曼构造结束*/
    
	//读取源文件中的每一个字符,按照设置好的编码替换文件中的字符
	fseek(ifp,0,SEEK_SET);					/*把文件指针指向文件的开头*/
    fwrite(&flength,sizeof(int),1,ofp);     /*把哈弗曼代码写入ofp文件*/
    fseek(ofp,8,SEEK_SET);                   /*以8位二进制数为单位读取*/
    buf[0] = 0; 
    f = 0; 
    pt1 = 8; 
    while(!feof(ifp)) 
    { 
        c=fgetc(ifp);        //从流中读取一个字符,并增加文件指针的位置
        f++; 
        for(i=0;i<n;i++) 
    	{ 
            if(c==header[i].b) 
				break; 
    	} 
        strcat(buf,header[i].bits); //把header[i].bits所指字符串添加到buf结尾处
        j = strlen(buf);            //计算字符串buf的长度
        c = 0; 
        while(j>=8)     /*按八位二进制数转化成十进制ASCII码写入文件一次进行压缩*/
    	{ 
            for(i=0;i<8;i++)  
        	{ 
                if(buf[i]=='1') c=(c<<1)|1; 
                else c=c<<1; 
        	} 
            fwrite(&c,1,1,ofp); 
            pt1++; 
            strcpy(buf,buf+8); 
            j=strlen(buf); 
    	} 
        if(f==flength) 
			break; 
    } 
    if(j > 0) /*剩余字符数量少于8个*/
    { 
        strcat(buf,"00000000"); 
        for(i=0;i<8;i++) 
    	{ 
            if(buf[i]=='1') c=(c<<1)|1; 
            else c = c << 1;     /*对不足的位数补0*/
    	} 
        fwrite(&c,1,1,ofp); 
        pt1++; 
    } 
	//将编码信息写入存储文件
	fseek(ofp,4,SEEK_SET);     /*fseek 用于二进制方式打开的文件,移动文件读写指针位置.第一个是文件流,第3个是指针零点位置,第2个是把指针移动到的地点. */
		fwrite(&pt1,sizeof(long),1,ofp); /*是要输出数据的地址,每次写入的位数,数据项的个数,目标文件地址*/
    fseek(ofp,pt1,SEEK_SET); 
    fwrite(&n,sizeof(long),1,ofp); 
	for(i=0;i<n;i++) 
    { 
        fwrite(&(header[i].b),1,1,ofp); 
        c=strlen(header[i].bits); 
        fwrite(&c,1,1,ofp); 
        j=strlen(header[i].bits); 
        if(j % 8!=0)             /*按八位读取,位数不满8位时,对该位补0*/    
    	{ 
            for(f=j%8;f<8;f++) 
                strcat(header[i].bits,"0"); 
    	} 
		while(header[i].bits[0]!=0) 
    	{ 
            c=0; 			
            for(j=0;j<8;j++) 
        	{ 
                if(header[i].bits[j]=='1') c=(c<<1)|1; 
                else c = c << 1; 
        	} 
            strcpy(header[i].bits,header[i].bits+8);  /*把从header[i].bits+8地址开始且含有NULL结束符的字符串赋值到以header[i].bits开始的地址空间 */
            fwrite(&c,1,1,ofp); 
    	} 
    } 
    fclose(ifp); 
    fclose(ofp); 
    printf("压缩成功\n"); 
   
} 
/*主函数*/
void main()                   
{
	printf("输入a开始压缩\n");
	printf("输入b结束压缩\n");
	while(1)
	{
		char c;
	    c=getch();
        if(c=='a')
			yasuo();
        else
		{
			if(c=='b')
			return;
		}
	}
}
3.测试结果分析

(1)运行截图如下

键入a,输入文件地址及文件名和压缩后的文件地址及文件名,在出现“压缩成功”后键入b,退出代码运行。
在这里插入图片描述(2)压缩结果展示
a.压缩前(只有一个文件)
在这里插入图片描述
打开后文件内容
在这里插入图片描述

b.压缩后(出现两个文件)
在这里插入图片描述
打开后文件内容
在这里插入图片描述

五、实验总结

本学期要学习课程很多,留给综合实验的时间并不是特别多。通过本次的实验,我又重新拿出了上学期的《C语言程序设计》,重新复习了一下一些关于文件读取、写入等函数。对于本次的实验内容,不仅仅是对本学期《数据结构与算法分析》的一个学习总结,更是对上学期C语言的复习回顾。

本次实验代码调试了很久,还是会出现一些C语言语法上的小错误,还有一部分内容参考了网上的代码。除了技术上的错误,在本次实验中我觉得还是要保持一个良好的心态去解决错误,在我的代码出现多次报错时,要能沉得住气去纠错,忌浮躁。

总之要学习的东西还有很多,每完成一次实验对我自己的能力来说都是一个很好的提升过程。作为大数据专业的学生,数学虽说是基础,但能够更好解决实际问题还是要靠计算机程序代码,学会一门语言不仅仅限于书本,更是要能够熟练地在实际中应用。学习是一个逐渐进步的过程,每次实验内容不仅仅是一次实验,更是一次对自己知识掌握的检验,更是对自己在面对新的挑战前的磨练。

  • 19
    点赞
  • 95
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang中的哈夫曼树编码是一种数据压缩算法,适用于将大数据量进行高效的压缩和解压缩操作。哈夫曼树编码的原理是根据字符出现的频率构建一棵树,出现频率较高的字符使用较短的编码,出现频率较低的字符使用较长的编码,从而实现数据的压缩。 在Golang中,可以使用哈夫曼树编码库来实现这一算法。首先,需要统计字符的出现频率,可以通过遍历待压缩的数据来进行统计。然后,根据字符的频率构建哈夫曼树,可以使用优先队列或堆来实现。 一旦构建好了哈夫曼树,就可以生成每个字符对应的哈夫曼编码。编码过程中,从根节点开始,遍历树的路径,当遇到左子树时将路径上加入0,遇到右子树时加入1,直到到达叶子节点,将路径上的编码记录下来。最终,每个字符对应的哈夫曼编码就是根据路径上的0和1组成的。 对于压缩数据,在编码时将每个字符替换成对应的哈夫曼编码,将压缩后的编码写入到新的文件中。对于解压缩数据,需要读取压缩文件中的编码,根据哈夫曼树的结构进行逐个字符的解码操作。 总而言之,Golang中的哈夫曼树编码是一种高效的数据压缩算法,通过统计字符出现的频率构建哈夫曼树,然后生成每个字符对应的哈夫曼编码,从而实现数据的压缩和解压缩操作。通过使用相关的库,可以方便地实现这一算法。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值