哈夫曼编码译码器绝对可以运行c语言

#include
# include
# include
# define maxsize 100
# define max 100
typedef struct 
{
	char data;
	int weight;
	int parent;
	int left;
	int right;
}huffnode;     //记录哈夫曼树结点的数据类型
typedef struct
{
	char cd[max];
	int start;   
}huffcode;  //记录哈夫曼编码的数据类型

void dq（huffnode * ht）  //初期化，读取字符串
{
	char st[100];
	FILE *fz;
	char j;
	int i=0nmcount=0x;
	printf（“1.手动输入字符串  2.读取字符串文件 0.退出\n“）;
	scanf（“%d“&x）;
	getchar（）;
	switch（x）
		{
		case 1:
			printf（“输入字符串:“）;
        	st[i]=getchar（）;
        	while（st[i]!=‘\n‘）
			{
	    	   i++;
		       count++;
		      st[i]=getchar（）;
			}
			break;
		case 2:
			fz=fopen（“hfmtree.txt““r“）;
			if（fz==NULL）
			{ 
				printf（“没有字符串文件。\n“）;
				return;
			}
			else
			{
				j=fgetc（fz）;
				while（j!=EOF）
				{
					count++;
					st[i]=j;
					i++;
					j=fgetc（fz）;
				}
				fclose（fz）;
			}
			break;
		case 0:
			break;
		default:
			printf（“输入错误。\n“）;
		}
	for（i=0m=1;i	{
		for（n=1;n<=m;n++）  //判断，频度表里面是有有当前字符
			if（st[i]==ht[n].data） //若有，对应的频度加1
			{	
				ht[n].weight++;	
				break;
			}			
			if（n>m）  //若没有，新增频度表，并初始化
			{
				ht[m].data=st[i];
				ht[m].weight=1;
				m++;
			}
	}
	ht[0].data=‘#‘;  //赋上特殊符号，用于判断是否空结点
	ht[0].weight=m-1;   //记录叶子数
	printf（“字符频度表：\n“）; //输出频度表
	for（i=1;i<=ht[0].weight;i++）{
			printf（“%c:“ht[i].data）;
			printf（“%d\n“ht[i].weight）;
	}
	
	
}
void input（char * zf）   //读取需要编码的文件，用数组记录文件内容
{
	FILE * in;
	char j;
	int i;
	in=fopen（“tobetrans.dat““r“）;
	if（in==NULL）
	{
		printf（“没有可编译的文件。\n“）;
		zf[0]=-1;
		return;
	}
	else
	{
		for（i=0;i<=100;i++）
		{
			j=fgetc（in）;  //读取字符
			if（j==EOF）
			{
				zf[i]=‘\0‘;
				return;
			}
			else
			{
				zf[i]=j; //记录字符
			}
		}
		
	}
	fclose（in）;
}
void select（huffnode * htint iint *s1int *s2） 
//找出权值最小的树，s1记录最小值下标，s2记录次最小指下标
{
	int x;
	int m1m2;
	m1=m2=1000;
	for（x=1;x<=i;x++）
		if（ht[x].parent==0）  //对没有父亲结点的结点，进行对比
		if（ht[x].weight		{
			m2=m1;       //最小值变成次最小值
            m1=ht[x].weight; //当前结点权值成为最小值
			*s2=*s1;    //最小值下标成为次最小值下标
			*s1=x;			//当前结点下标成为最小值小标
		}
		else
			if（ht[x].weight			{
				m2=ht[x].weight; //当前结点的权值成为次最小值
				*s2=x;   //该下标成为次最小值下标
			}
}
void hfmtree（huffnode * ht）    //生成哈夫曼树
{ 
	int ix1=0x2=0n;
	n=ht[0].weight;
	for（i=1;i<=2*n-1;i++）
		ht[i].parent=ht[i].left=ht[i].right=0;  //初始化
	for（i=n+1;i<=2*n-1;i++）
	{
	        select（hti-1&x1&x2）;
			ht[x1].parent=i;
			ht[x2].parent=i;
			ht[i].weight=ht[x1].weight+ht[x2].weight; //合并
			ht[i].left=x1;  
			ht[i].right=x2;
	}
	
}
void hcc（huffnode * htt）    //存储哈夫曼树于文件hfmtree.bin
{
	FILE * fht;
	int i=0;
	fht=fopen（“hfmtree.bin““wb“）;
	if（fht==NULL） printf（“建立文件hfmtree.bin失败。\n“）;
	else
	{
		fwrite（&htt[i]sizeof（huffnode）2*htt[0].weightfht）;
		fclose（fht）;
	}
}
void dhf（huffnode *