哈夫曼建树、编码、解码加强版

最新推荐文章于 2022-07-20 18:09:55 发布
最新推荐文章于 2022-07-20 18:09:55 发布
阅读量899 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smile_7x/article/details/8449587
版权
直接上代码，注释详解 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//
/*定义赫夫曼树结点的结构体变量，存放结点的权值、字符、双亲、坐孩子和右孩子*/
typedef struct
{   
	int weight;   
    char ch;                 //增加一个域用于存放该节点的字符
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char **HuffmanCode; //指向赫夫曼编码的指针

//
/*本程序用到的函数原型*/
void welcome();    //打印操作选择界面
void HuffmanCoding(HuffmanTree &,char *,int *,int);//建立赫夫曼树的算法
void select(HuffmanTree HT,int j,int *s1,int *s2); //从目前已建好的赫夫曼树中选择parent为0且weight最小的两个结点
void Init(); //输入n个字符及其对应的权值，根据权值建立哈夫曼树
void Coding(); //编码
void Decoding(); //译码
void Print_code(); //打印译码好的代码文件
void Print_tree(); //以凹凸表形式打印哈夫曼树
int Read_tree(HuffmanTree &); //从文件中读入赫夫曼树
void find(HuffmanTree &HT,char *code,char *text,int i,int m);//译码时根据01字符串寻找相应叶子节点的递归算法
void Convert_tree(unsigned char T[100][100],int s,int *i,int j);//将内存中的赫夫曼树转换成凹凸表形式的赫夫曼树

HuffmanTree HT; //全局变量，指向存放赫夫曼树的存储空间
int n=0; //全局变量，存放赫夫曼树叶子结点的数目

int main()
{
	char select;
	while(1)
	{
		welcome();
		scanf("%c",&select);
		switch(select)
		{
		case 'i':
		case 'I':Init();break;
        case 'c':
        case 'C':Coding();break;
        case 'd':
        case 'D':Decoding();break;
        case 'p':
        case 'P':Print_code();break;
        case 't':
        case 'T':Print_tree();break;
        case 'e':
        case 'E':exit(1);
        default :printf("Input error!\n");
		}
        getchar();
	}
    return 0;
}

void welcome() //打印操作选择界面
{
	printf("*-----------------------------------------------------*\n");
    printf("|                你想干什么？                         |\n");
    printf("|-----------------------------------------------------|\n");
    printf("|                                                     |\n");
    printf("| I--------------------------建立哈夫曼树.            |\n");
    printf("| C--------------------------哈夫曼树编码.            |\n");
    printf("| D--------------------------哈夫曼树译码.            |\n");
    printf("| P--------------------------输出codefile文件.        |\n");
    printf("| T--------------------------输出哈夫曼树.            |\n");
	printf("| E--------------------------退出.                    |\n");
    printf("|                                                     |\n");
    printf("*-----------------------------------------------------*\n");
}

//
/*初始化函数，输入n个字符及其对应的权值，根据权值建立哈夫曼树，并将其存于文件hfmtree中*/
void Init() 
{
	FILE *fp;
    int i,n,w[52]; //w数组存放n个字符的权值
    char character[52]; //存放n个字符
    printf("\n输入字符个数 n:");
    scanf("%d",&n);        //输入字符集大小
    printf("输入%d个字符:\n",n);
    for (i=0;i<n;i++)
	{
		char b=getchar();
        scanf("%c",&character[i]);          //输入n个字符
	}
	printf("输入%d个对应的权值:\n",n);
	for(i=0;i<n;i++)
	{
		char b=getchar();
		scanf("%d",&w[i]);                  //输出n个对应权值
	}
    HuffmanCoding(HT,character,w,n);    //建立赫夫曼树
	if((fp=fopen("hfmtree.txt","w"))==NULL)
		printf("Open file hfmtree.txt error!\n");
    for (i=1;i<=2*n-1;i++)
	{
		if(fwrite(&HT[i],sizeof(HTNode),1,fp)!=1)   //将建立的赫夫曼树存入文件hfmtree.txt中
			printf("File write error!\n");
	}
	printf("\n建立赫夫曼树成功，已将其存于文件hfmtree.txt中\n");
	fclose(fp);
}

///
//建立赫夫曼树的算法///
void HuffmanCoding(HuffmanTree &HT,char *character,int *w,int n)
{
	int m,i,s1,s2;
	HuffmanTree p;
	if(n<=1) return;
	m=2*n-1;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
	for(p=HT+1,i=1;i<=n;++i,++p,++character,++w)
	{
		p->ch=*character;p->weight=*w;p->parent=0;p->lchild=0;p->rchild=0;
	}
	for(;i<=m;++i,++p) 
	{
		p->ch=0;p->weight=0;p->parent=0;p->lchild=0;p->rchild=0;
	}
	for(i=n+1;i<=m;++i)
	{
		select(HT,i-1,&s1,&s2);
        HT[s1].parent=i;HT[s2].parent=i;
        HT[i].lchild=s1;HT[i].rchild=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;
	}
}

///
/*从HT[1]到HT[j]中选择parent为0且weight最小的两个结点，用s1和s2返回其序号*/
void select(HuffmanTree HT,int j,int *s1,int *s2)
{
	int i;//找weight最小的结点
	for (i=1;i<=j;i++) 
		if (HT[i].parent==0)
		{
			*s1=i;break;
		}
		for (;i<=j;i++)
			if ((HT[i].parent==0)&&(HT[i].weight<HT[*s1].weight))
				*s1=i;
			HT[*s1].parent=1;//找weight次小的结点
			for (i=1;i<=j;i++)
				if (HT[i].parent==0)
				{
					*s2=i;break;
				}
				for (;i<=j;i++)
					if ((HT[i].parent==0)&&(i!=*s1)&&(HT[i].weight<HT[*s2].weight))
						*s2=i;
}

///
/*对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中*/
void Coding() 
{
	FILE *fp,*fw;
	int i,f,c,start;
	char *cd;
	HuffmanCode HC;
	if(n==0)
		n=Read_tree(HT);//从文件hfmtree.txt中读入赫夫曼树,返回叶子结点数
	
    /以下程序段求赫夫曼树中各叶子节点的字符对应的的编码，并存于HC指向的空间中
	{
		HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
		cd=(char *)malloc(n*sizeof(char));
		cd[n-1]='\0';
		for(i=1;i<=n;++i)
		{
			start=n-1;
			for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
				if(HT[f].lchild==c)
					cd[--start]='0';
				else cd[--start]='1';
				HC[i]=(char *)malloc((n-start)*sizeof(char));
				strcpy(HC[i],&cd[start]);
		}
		free(cd);
	}
	/
	if((fp=fopen("tobetrans.txt","rb"))==NULL)
		printf("Open file tobetrans.txt error!\n");
	if((fw=fopen("codefile.txt","wb+"))==NULL)
		printf("Open file codefile.txt error!\n");
	char temp;
	fscanf(fp,"%c",&temp); //从文件读入第一个字符
	while(!feof(fp))
	{
		//printf("aaaaaaaaa\n");
		for(i=1;i<=n;i++) 
			if(HT[i].ch==temp) break;    //在赫夫曼树中查找字符所在的位置
			for(int r=0;HC[i][r]!='\0';r++) //将字符对应的编码存入文件
			{
				fputc(HC[i][r],fw);
				//fwrite(&HC[i][r],sizeof(HTNode),1,fw);
				//fwrite(&HT[i],sizeof(HTNode),1,fp)
				//printf("bbbbbbb\n");
			}
			fscanf(fp,"%c",&temp);        //从文件读入下一个字符	
	}
	fclose(fw);
	fclose(fp);
	printf("\n对文件hfmtree.txt编码成功,结果已存入codefile.txt中。\n\n");
}


/
/*将文件codefile中的代码进行译码，结果存入文件textfile中*/
void Decoding() 
{
	FILE *fp,*fw;
	int m,i;
	char *code,*text,*p;
	
    if(n==0)
		n=Read_tree(HT);//从文件hfmtree.txt中读入赫夫曼树,返回叶子结点数
	
	if((fp=fopen("codefile.txt","rb"))==NULL)
		printf("Open file codefile.txt error!\n");
	if((fw=fopen("textfile.txt","wb+"))==NULL)
		printf("Open file textfile.txt error!\n");
	code=(char *)malloc(sizeof(char));
	fscanf(fp,"%c",code);        //从文件读入一个字符
	for(i=1;!feof(fp);i++)
	{
		code=(char *)realloc(code,(i+1)*sizeof(char)); //增加空间
		fscanf(fp,"%c",&code[i]);     //从文件读入下一个字符 
	}
	code[i-1]='\0';
	/到此codefile.txt文件中的字符已全部读入，存放在code数组中
    text=(char *)malloc(100*sizeof(char));
	p=text;
    m=2*n-1;
	if(*code=='0')
		find(HT,code,text,HT[m].lchild,m);   //从根节点的左子树去找
	else
		find(HT,code,text,HT[m].rchild,m);   //从根节点的右子树去找
	
    for(i=0;p[i]!='\0';i++) //把译码好的字符存入文件textfile.txt中
		fputc(p[i],fw);
	
	fclose(fp);
	fclose(fw);
	
	printf("\n对codefile.txt文件译码成功，结果已存入textfile.txt文件。\n\n");
}

//
/*将文件codefi1e以紧凑格式显示在终端上,每行50个代码。同时将此字符形式的编码文件写入文件codeprint中。*/
void Print_code()
{
	FILE *fp,*fw;
	char temp;
	int i;
    if((fp=fopen("codefile.txt","rb"))==NULL)
		printf("Open file codefile.txt error!\n");
	if((fw=fopen("codeprint.txt","wb+"))==NULL)
		printf("Open file codeprint.txt error!\n");
	printf("\n文件codefi1e以紧凑格式显示如下:\n");
	fscanf(fp,"%c",&temp);        //从文件读入一个字符
	for (i=1;!feof(fp);i++)
	{  
		printf("%c",temp);
		if(i%50==0) printf("\n");
		fputc(temp,fw);   //将该字符存入文件codeprint.txt中
		fscanf(fp,"%c",&temp);        //从文件读入一个字符
	}
	printf("\n\n此字符形式的编码已写入文件codeprint.txt中.\n\n");
	fclose(fp);
	fclose(fw);	
}

//
/*将已在内存中的哈夫曼树以凹凸表形式显示在屏幕上，同时将此字符形式的哈夫曼树写入文件treeprint中。*/
void Print_tree()
{
	unsigned char T[100][100];
	int i,j,m=0;
	FILE *fp;
	if(n==0)
		n=Read_tree(HT);//从文件hfmtree.txt中读入赫夫曼树,返回叶子结点数
	
	Convert_tree(T,0,&m,2*n-1); //将内存中的赫夫曼树转换成凹凸表形式的树，存于数组T中
	
	if((fp=fopen("treeprint.txt","wb+"))==NULL)
		printf("Open file treeprint.txt error!\n");
    printf("\n以凹凸表形式打印已建好的赫夫曼树：\n");
	for(i=1;i<=2*n-1;i++)
	{
		for (j=0;T[i][j]!=0;j++)
		{
			if(T[i][j]==' ') {printf(" ");fputc(T[i][j],fp);}
			else
			{printf("%d",T[i][j]);fprintf(fp,"%d\n",T[i][j]);}
		}
		printf("\n");
	}
	fclose(fp);
	printf("\n此字符形式的哈夫曼树已写入文件treeprint.txt中.\n\n");
	
}

//
/*从文件hfmtree.txt中读入赫夫曼树，返回叶子节点数*/
int Read_tree(HuffmanTree &HT) 
{
	FILE *fp;
	int i,n;
	HT=(HuffmanTree)malloc(sizeof(HTNode));
    if((fp=fopen("hfmtree.txt","r"))==NULL)
		printf("Open file hfmtree.txt error!\n");
	for (i=1;!feof(fp);i++)
	{
		HT=(HuffmanTree)realloc(HT,(i+1)*sizeof(HTNode)); //增加空间
		fread(&HT[i],sizeof(HTNode),1,fp); //读入一个节点信息
	}
	fclose(fp);
	n=(i-1)/2;
	return n;
}


/*译码时根据01字符串寻找相应叶子节点的递归算法*/
void find(HuffmanTree &HT,char *code,char *text,int i,int m)
{
	
	if(*code!='\0') //若译码未结束
	{
		code++;
		if(HT[i].lchild==0&&HT[i].rchild==0)   //若找到叶子节点
		{
			
			*text=HT[i].ch; //将叶子节点的字符存入text中
			
			text++;
			if((*code=='0'))
				find(HT,code,text,HT[m].lchild,m); //继续从根节点的左子树找
			else
				find(HT,code,text,HT[m].rchild,m); //继续从根节点的右子树找
		}
		else   //如果不是叶子节点
			if(*code=='0')
				find(HT,code,text,HT[i].lchild,m);   //从该节点的左子树去找
			else
				find(HT,code,text,HT[i].rchild,m);   //从该节点的右子树去找
			
			
	}
	else
		*text='\0'; //译码结束
	
}


/*将内存中的赫夫曼树转换成凹凸表形式的赫夫曼树*/
void Convert_tree(unsigned char T[100][100],int s,int *i,int j)
{
	int k,l;
	l=++(*i);
	for(k=0;k<s;k++)
		T[l][k]=' ';
	T[l][k]=HT[j].weight;
	if(HT[j].lchild)
		Convert_tree(T,s+1,i,HT[j].lchild);
	if(HT[j].rchild)
		Convert_tree(T,s+1,i,HT[j].rchild);
	T[l][++k]='\0';
}

Smile_7x
关注
哈夫曼树建树等部分代码
sdutplacmer的博客
05-16 301
哈夫曼树部分代码 哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL=(W1L1+W2L2+W3L3+…+ WnLn)，N个权值Wi(i=1,2,…n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,…n)。可以证明哈夫曼树的WPL是最小的。 构造哈夫曼树的算法如下： 1）对给定的n个权值{W1,W2,W3,…,Wi,…,
哈夫曼树的创建（详细步骤）
热门推荐
qq_47142993的博客
08-03 1万+
// 构造赫夫曼树 #include <iostream> using namespace std; //哈夫曼树的存储表示 typedef struct { int weight; //节点的权值 int parent, lchild, rchild; //节点的双亲，左孩子和右孩子 } HTNode, *HuffmanTree; //查处权值最小且双亲为0的2的节点 void Select(HuffmanTree HT, int len, i
哈夫曼建树
weixin_30699235的博客
05-22 64
输入是各个叶子节点的值，第一个是数值的个数，然后先序遍历这棵树 #include<iostream> #include<queue> using namespace std; int n; struct tree { int data; tree * lson; tree * rson; }*ans; struct f ...
数据结构：N之后的问题和哈夫曼
m0_62600887的博客
05-28 339
N后问题：在n×n格的棋盘上放置彼此不受攻击的n个皇后，按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子，请输出皇后的位置以及对应皇后的解法个数。 照搬代码 #include<stdio.h> #include<malloc.h> #include<math.h> /* *place it there ,application */ bool place(int* paraSolution,int paraT){ i..
哈夫曼树（哈夫曼建树及编码）
narutolzj的专栏
10-02 652
哈夫曼树是数据结构的一种，用于实现无损压缩。压缩分为无损压缩和有损压缩，使用哈夫曼压缩的压缩比可达3:1到5:1，流行的有损压缩方法有lzw字典压缩等。 几个名词解释：        最优二叉树：树的加权路径总长度最短的二叉树。        权值：每个叶子节点带有一定的权值，在哈夫曼树中为该叶子节点代表的字符的出现频率。        树的加权路径总长度：各叶子节点到根节点的路径长度与...
C++实现哈夫曼树编码解码
08-19
C++实现哈夫曼树编码解码 哈夫曼树是一种特殊的二叉树，它的每个叶节点都带有一个权值，用于表示该节点的重要性或频率。哈夫曼树编码解码是指使用哈夫曼树来对数据进行编码和解码，以达到数据压缩和解压缩的目的。...
数字彩色图像的哈夫曼编码与解码的matlab实现
05-23
哈夫曼编码(Huffman Coding)，是一种熵编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般...
哈夫曼编码与解码(C语言实现)
06-01
在压缩文件时，除了生成哈夫曼编码，还需要将编码结果和哈夫曼树的结构信息（例如每个节点的频率和左右子节点的编码）保存下来，以便解码时使用。通常，我们可以将编码后的数据和结构信息写入到一个文件中，形成压缩...
数据结构课程设计 哈夫曼树编码解码 java javafx
05-28
利用哈夫曼编码进行信息通讯可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码；在接收端将传来的数据进行译码(复原)。对于双工信道 (即可以双向...
哈夫曼树的建立
DL猿
10-16 774
存储结构: class node{ public: int weight; 权值域，保存该节点的权值 int lchild; 指针域，结点的左孩子在数组中的下标 int rchild; 指针域 结点的右孩子在数组中的下标 int parent; 指针域，该节点的双亲结点在数组中的下标 } 性质: 在构建哈夫曼树的过程，只有出度为0和2的结点， 在二叉树中 n0 = n2 + 1 ------》 n2 = n0-1 代入...
哈夫曼树C++实现
04-24
数据结构编码实战：哈夫曼树c++实现可以 定义，哈夫曼各种函数实现
Hfm树
02-24
Hfm树 这里解释一些用户输入： 一般操作： I：（Initialization）从终端输入字符集与权重，要求输入保存位置和字符集大小。 E ：（编码）对现有文件进行编码并保存到新文件，编码文件为二进制文件。源文件与目标文件均需要用户指定。若内存中不存在哈夫曼树，将要求输入现有哈夫曼树文件位置，且此文件要求为已建立完成的哈夫曼树。若为不完整的哈夫曼树，解决方法在后文。 D ：（解码）对现有编码文件进行转换，并且编码文件要求为二进制文件，若以字符编码请自行转换。源文件与目标文件均需要用户指定。若内存中不存在哈夫曼树，如E功能解决。 P ：（打印）将二进制文件转换为文本编码，显示在终端并保存在用户指定文件，每行显示50个代码。 T ：（树打印）将内存中的哈夫曼树以凹入表形式显示在终端并保存在用户指定文件。 问：（退出）退出程序并释放内存。 拓展操作： C ：（代码表）打印哈夫曼编
哈夫曼编译码系统,编译哈夫曼树，数据结构中使用的。
04-15
一个完整的系统应具有以下功能： （1） I： 初始化。从终端读入字符集大小 n ，及 n 个字符和 n 个权值，建立哈夫曼树，并将其存于文件hfmtree中。 （2） C： 编码。利用已建好的哈夫曼树（如不在内存，则从文件hfmtree中读入），对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中。 （3） D： 译码。利用已建好的哈夫曼树将文件codefile中的代码进行译码，结果存入文件textfile中。 （4） P： 打印代码文件。将文件codefi1e以紧凑格式显示在终端上,每行50个代码。同时将此字符形式的编码文件写入文件codeprint中。 （5） T：打印哈夫曼树。将已在内存中的哈夫曼树以直观的方式（树或凹凸表形式）显示在屏幕上，同时将此字符形式的哈夫曼树写入文件treeprint中。
哈夫曼树 构造，编码 完整代码
m0_61628700的博客
04-04 2766
Haffman Tree 构造方法： 1.初始化每个叶子结点都是一棵树。 2.找最小权值的两棵树。 3.合并两树，生成新结点。 编码： 1.往左为1，右为0. 2.不等长编码。 #include<stdio.h> #include<malloc.h> #include<stdlib.h> ​ #define MaxN 100 //最大结点个数 #define Maxbit 255 //最大编码值 #define MaxValue 9999 //最大权
哈弗曼树
weixin_44266050的博客
02-19 527
文章目录例子建树思路数据结构主函数HFM建树（子函数：初始化+找最小两点，然后在函数内遍历补充树的信息）HFM编码（在建树的基础上获得编码）方法一：自底向上分析的原题：问题 A: 算法6-12：自底向上的赫夫曼编码思路数据结构主函数HFM建树（子函数：初始化+找最小两点，然后在函数内遍历补充树的信息）HFM编码（自底向上）AC代码方法二：自顶向下1.递归AC代码2.递推AC代码 例子 输入   输...
哈夫曼树
happy_zhourong
05-02 210
一、哈夫曼树的定义： 哈夫曼树：又称最优二叉树，是一种带权路径最短的树。 树的路径长度：从树根到树中每一个节点的路径长度之和。 结点之间的路径长度：从一个结点到另一个结点之间的分支数目。 结点的带权路径长度：从该结点到树根之间的路径长度与节点上权的乘积。 树的带权路径长度：Weighted Path Length of Tree，简称为WPL,树中所有叶子结点的带权路径长度之和，记作...
Huffman树及其应用
杨森源的博客
06-01 3929
最优二叉树（赫夫曼树）                 路    径：由一结点到另一结点间的分支所构成。         路径长度：路径上的分支数目。a→e的路径长度＝2         树的路径长度：从树根到每一结点的路径长度之和。树长度＝10         结点的权：一些应用中，赋予树中结点的一个有某种意义的实数。         带权路径长度：结点到根的路径长度与结点上权的乘
哈夫曼树的创建
qq_52165267的博客
11-05 1375
哈夫曼树 目录哈夫曼树1. 什么是哈夫曼树2. 创建哈夫曼树2.1 创建树节点TreeNode2.2 构建哈夫曼树2.3 测试 1. 什么是哈夫曼树 2. 创建哈夫曼树 2.1 创建树节点TreeNode //树的节点 public class TreeNode { /** * 值 * 左右孩子 */ private int value; public TreeNode left; public TreeNode right; pub
哈夫曼树的构建
weixin_54802873的博客
07-20 3170
哈夫曼树的构建
哈夫曼编码与解码实现详解
"这篇文档是关于哈夫曼编码与解码的实现，旨在帮助读者理解和掌握这一数据压缩技术。" 哈夫曼编码是一种高效的前缀编码方法，常用于数据压缩，其基本思想是通过构建一棵特殊的二叉树（哈夫曼树）来为每个字符或符号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值