go语言实现哈夫曼编码,go语言编码规范

哈夫曼编码问题，高手帮我

#includestdio.h

成都创新互联公司专业为企业提供虎林网站建设、虎林做网站、虎林网站设计、虎林网站制作等企业网站建设、网页设计与制作、虎林企业网站模板建站服务，十年虎林做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

#includestring.h

#includestdlib.h

#includectype.h

int n;

struct node{

int w;

int flag;

char c;

struct node *plink,*llink,*rlink;

char code[50];

}*num[100],*root;

FILE *fp;

char tmpcode[50];

int t=0;

void main(void)

{

int i;

void settree(void); //建立树

void code(void); //对文件编码

void decode(void); // 译码

void disp(void);

root=(struct node*)malloc(sizeof(struct node));

puts("*******************哈夫曼编/译码器演示******************************");

while(1){

start:

puts("1. 初始化 2. 编码 3. 译码 4.显示编码表 5. 退出");

while(scanf("%d",i)!=1)

{

while(getchar()!='\n')

continue;

puts("输入错误!");

puts("请重新输入！");

puts("1. 初始化 2. 编码 3. 译码 4.显示编码表 5. 退出");

}

switch (i)

{

case 1:

settree();

break;

case 2:

code();

break;

case 3:

decode();

break;

case 4:

disp();

break;

case 5:

exit(0);

default:

puts("输入错误！");

puts("请重新输入！");

goto start;

}

}

}

void settree(void)

{

int i,j,k;

struct node *p1,*p2,*tmp,*p;

void go(struct node *);

void setcode(struct node *);//建立每一个字符的编码

void printtree(struct node *);

puts("输入字符集的大小：");

scanf("%d",n);

while(getchar()!='\n')

continue;

for(i=0;in;i++)

{

p=(struct node *)malloc(sizeof(struct node));

puts("请输入一个字符");

scanf("%c",p-c);

while(getchar()!='\n')

continue;

puts("请输入该字符的权值:");

scanf("%d",p-w);

while(getchar()!='\n')

continue;

p-plink=NULL;

p-rlink=NULL;

p-llink=NULL;

num[i]=p;

}

for(i=0;in-1;i++) //（递增）排序

{

for(j=i+1;jn;j++)

{

if(num[i]-wnum[j]-w)

{

tmp=num[i];

num[i]=num[j];

num[j]=tmp;

}

}

}

/*******************************开始建立树***********************/

num[n]=NULL; //结束标志

k=n;

while(num[1]!=NULL)

{

p=(struct node *)malloc(sizeof(struct node));

p1=num[0];

p2=num[1];

p-llink=p1;

p-rlink=p2;

p-plink=NULL;

p1-plink=p;

p2-plink=p;

p-w=p1-w+p2-w;

for(i=1;ik;i++)

{

num[i]=num[i+1];

}

k--;

num[0]=p;

for(i=0;ik-1;i++) //排序

{

for(j=i+1;jk;j++)

{

if(num[i]-wnum[j]-w)

{

tmp=num[i];

num[i]=num[j];

num[j]=tmp;

}

}

}

}

root=num[0];

/*建立完毕*/

/*写入文件，前序*/

if((fp=fopen("c:\\hfmtree.wxl","wb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

setcode(root);

go(root);

fclose(fp);

}

void setcode(struct node *p)

{

if(p-llink==NULLp-rlink==NULL)

{

tmpcode[t]='\0';

strcpy(p-code,tmpcode);

}

else

{

tmpcode[t++]='0';

setcode(p-llink);

t--;

tmpcode[t++]='1';

setcode(p-rlink);

t--;

}

}

void go(struct node *p)

{

if(p-llink==NULLp-rlink==NULL)

{

fputc('(',fp);

fputc(p-c,fp);

fputs(p-code,fp);

fputc(')',fp);

}

else

{

go(p-llink);

go(p-rlink);

}

}

void code(void)

{

FILE *fp1,*fp2,*fp3;

char ch1,ch2,c;

if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

if((fp2=fopen("c:\\tobetrans.txt","wb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

if((fp3=fopen("c:\\codefile.wxl","wb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

while((ch1=fgetc(fp2))!=EOF)

{

t=0;

while((ch2=fgetc(fp1))!=EOF)

{

if(ch1==ch2)

{

while((c=fgetc(fp1))!=')')

{

tmpcode[t++]=c;

}

tmpcode[t]='\0';

fputs(tmpcode,fp3);

fputc('@',fp3);

rewind(fp1);

break;

}

}

}

fclose(fp1);

fclose(fp2);

fclose(fp3);

}

void decode(void)

{

FILE *fp1,*fp2,*fp3;

char ch1,ch2,ch3;

char temp_3[20];

char temp_1[20];

int t1,t3;

if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

if((fp2=fopen("c:\\textfile.txt","wb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

if((fp3=fopen("c:\\codefile.wxl","rb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

while((ch3=fgetc(fp3))!=EOF)

{

t3=0;

while(ch3!='@')

{

temp_3[t3++]=ch3;

ch3=fgetc(fp3);

}

temp_3[t3]='\0';

while((ch1=fgetc(fp1))!=EOF)

{

if(isalpha(ch1))

{

ch2=ch1;

t1=0;

while((ch1=fgetc(fp1))!=')')

{

temp_1[t1++]=ch1;

}

temp_1[t1]='\0';

if(strcmp(temp_1,temp_3)==0)

{

fputc(ch2,fp2);

rewind(fp1);

break;

}

}

}

}

fclose(fp1);

fclose(fp2);

fclose(fp3);

}

void disp(void)

{

FILE *fp1,*fp2;

char ch1,ch2;

char tmp[20];

int t;

if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

if((fp2=fopen("c:\\hfmcode.txt","wb"))==NULL)

{

puts("文件打开错误！");

getchar();

exit(0);

}

while((ch1=fgetc(fp1))!=EOF)

{

if(ch1=='(')

{

t=0;

ch1=fgetc(fp1);

ch2=ch1;

while((ch1=fgetc(fp1))!=')')

{

tmp[t++]=ch1;

}

tmp[t]='\0';

printf("%c-----%s\n",ch2,tmp);

fputc(ch2,fp2);

fputc('-',fp2);

fputc('-',fp2);

fputc('-',fp2);

fputs(tmp,fp2);

fputc('\n',fp2);

}

}

fclose(fp1);

fclose(fp2);

}

哈夫曼树及哈夫曼编码译码的实现（根据程序画流程图及对每句程序注释）

这是以前写的，可是我不想加注释了，Huffman编码其实原理很简单的，你自己好好学下吧，一句一句注释也太夸张了啊。

#includestring.h

#includestdlib.h

#includestdio.h

int m,s1,s2;

typedef struct {

unsigned int weight;

unsigned int parent,lchild,rchild;

}HTNode,*HuffmanTree;

typedef char ** HuffmanCode;

void Select(HuffmanTree HT,int n)

{

int i,j;

for(i=1;i=n;i++)

if(HT[i].parent==0)

{s1=i;

break;

}

for(j=i+1;j=n;j++)

if(HT[j].parent==0)

{

s2=j;

break;

}

for(i=1;i=n;i++)

{

if(HT[i].parent==0)

if(HT[s1].weightHT[i].weight)

if(s2!=i)

s1=i;

}

for(j=1;j=n;j++)

{

if(HT[j].parent==0)

if(HT[s2].weightHT[j].weight)

if(s1!=j)

s2=j;

}

if(s1s2)

{

int temp=s1;

s1=s2;

s2=temp;

}

}

void HuffmanCoding(HuffmanTree HT, HuffmanCode HC, int *w, int n)

{

int i,j;

char *cd;

int p;

int cdlen;

if (n=1) return;

m = 2 * n - 1;

HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode));

for (i=1; i=n; i++)

{

HT[i].weight=w[i-1];

HT[i].parent=0;

HT[i].lchild=0;

HT[i].rchild=0;

}

for (i=n+1; i=m; i++)

{

HT[i].weight=0;

HT[i].parent=0;

HT[i].lchild=0;

HT[i].rchild=0;

}

//添加查看，便于调试

printf("构造过程显示：\n");

for(i=1;i=m;i++)

printf("%4d%4d%4d%4d%4d\n",i,HT[i].weight, HT[i].parent,HT[i].lchild, HT[i].rchild);

system("pause");

for(i=n+1;i=m;i++)

{

Select(HT,i-1);

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;

//添加查看，便于调试

/*printf("s1=%d,s2=%d\n",s1,s2);

for(j=1;j=i;j++)

printf("%d%4d%4d%4d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);

system("pause");

*/

}

cd = (char *)malloc(n*sizeof(char));

p=m;

cdlen=0;

for(i=1;i=m;i++)

HT[i].weight=0;

while(p)

{

if(HT[p].weight==0)

{

HT[p].weight=1;

if(HT[p].lchild!=0)

{

p=HT[p].lchild;

cd[cdlen++]='0';

}

else if(HT[p].rchild==0)

{

HC[p]=(char *)malloc((cdlen+1)*sizeof(char));

cd[cdlen]='\0';

strcpy(HC[p],cd);

}

}

else if(HT[p].weight==1)

{

HT[p].weight=2;

if(HT[p].rchild!=0)

{

p=HT[p].rchild;

cd[cdlen++]='1';

}

}

else

{

HT[p].weight=0;

p=HT[p].parent;

--cdlen;

}

}

}

int main()

{

HuffmanTree HT;

HuffmanCode HC;

int *w,n,i;

printf("请输入节点数：\n");

scanf("%d",n);

HC = (HuffmanCode)malloc(n*sizeof(HuffmanCode));

w=(int *)malloc(n*sizeof(int));

printf("请输入节点的权值：\n");

for(i=0;in;i++)

scanf("%d",w[i]);

HuffmanCoding(HT,HC,w,n);

printf("输出编码：\n");

for(i=1;i=n;i++)

printf("%2d(%4d):%s\n",i,w[i-1],HC[i]);

return 0;

system("pause");

}

利用 数据结构 实现 哈夫曼编码/译码实现

//D:\2010 代码\haffman\haffman\Node_statement.h

#define MAXVALUE 1000//定义最大权值

#define MAXBIT 100//定义哈夫曼树中叶子结点个数

typedef struct

{

char data;//字符值

int num;//某个值的字符出现的次数

}TotalNode;

//统计结点，包括字符种类和出现次数

typedef struct

{

TotalNode tot[300];//统计结点数组

int num;//统计数组中含有的字符个数

}Total;

//统计结构体，包括统计数组和字符种类数

typedef struct

{

char mes[300];//字符数组

int num;//总字符数

}Message;

//信息结构体，包括字符数组和总字符数

typedef struct{

int locked[500];//密码数组

int num;//密码总数

}Locking;

//哈夫曼编码后的密文信息

typedef struct

{

char data;//字符

int weight;//权值

int parent;//双亲结点在数组HuffNode[]中的序号

int lchild;//左孩子结点在数组HuffNode[]中的序号

int rchild;//右孩子结点在数组HuffNode[]中的序号

}HNodetype;

//哈夫曼树结点类型，包括左右孩子，权值和信息

typedef struct

{

int bit[MAXBIT];

int start;

}HCodetype;

//哈夫曼编码结构体，包括编码数组和起始位

void reading_file(Message *message);//从文件中读取信息

int writing_file(Message *message);//将信息写进文件

void total_message(Message *message,Total *total);//统计信息中各字符的次数

void HaffmanTree(Total *total,HNodetype HuffNode[]);//构建哈夫曼树

void HaffmanCode(HNodetype HuffNode[],HCodetype HuffCode[],Total *total);//建立哈夫曼编码

void writing_HCode(HNodetype HuffNode[],HCodetype HuffCode[],Total *total);//将编码规则写进文件

void lock(Message *message,HNodetype HuffNode[],HCodetype HuffCode[],Total *total,Locking *locking);//给文件信息加密编码

void writing_lock(Locking *locking);//将已编码信息写进文件

void first_function(HNodetype HuffNode[],HCodetype HuffCode[],Total *total,Message *message);

void display(Total *total,HNodetype HuffNode[]);

void writing_translate(Locking *locking,HCodetype HuffCode[],HNodetype HuffNode[],Total *total);//将已编码信息翻译过来并写进文

//D:\2010 代码\haffman\haffman\function_mian.cpp

#include"Node_statement.h"

#includeiostream

#includefstream

#include "cstdlib"

using namespace std;

int main()

{

int i,j,choice,mark=0;//mark标记文件信息是否读入到内存中

HNodetype HuffNode[500];//保存哈夫曼树中各结点信息

HCodetype HuffCode[300];

Locking *locking;

Total *total;

Message *message;

locking=new Locking;

locking-num=0;

total=new Total;

total-num=0;

message=new Message;

message-num=0;

//初始化变量

printf("┏ ┓\n");

printf("┣ haffman_code system ┫ \n");

printf("┗ ┛\n");

printf("\n\n");

choice=0;

while(choice!=7 )

{

printf("＃〓§〓〓〓〓〓§〓〓〓〓§〓〓〓〓§〓＃ \n ");

printf(" 0:go \n");

printf("※********** 1：从文件读取信息**********************※\n");

printf(" *********** 2：显示编码规则 ********************* \n");

printf(" ********** 3：将原文件信息写进文件 ************ \n");

printf(" ********* 4：将编码规则写进文件 ************ \n");

printf(" ********** 5：将编码后的信息写进文件 ********** \n");

printf(" *********** 6：将译码后的信息写进文件 *********\n");

printf("※***********7：退出 *****************************※\n");

printf("＃〓§〓〓〓〓〓§〓〓〓〓§〓〓〓〓§〓＃ \n ");

printf(" please input the choice ");

cinchoice;

switch(choice)

{

case 1:

reading_file(message);//从文件中读取信息

mark=1;

break;

case 2://显示编码规则

if(mark==0)cout"请先从文件中读取信息!"endl;

else

{

first_function(HuffNode,HuffCode,total,message);

cout"编码规则为"endl;

for(i=0;itotal-num;i++)//显示编码规则

{

couttotal-tot[i].data" ";

for(j=HuffCode[i].start+1;jtotal-num;j++)

coutHuffCode[i].bit[j];

coutendl;

}

}

break;

case 3://将原文件信息写进文件a_test1.txt

if(mark==0)cout"请先从文件中读取信息!"endl;

else

writing_file(message);//将信息写进文件

break;

case 4://将编码规则写进文件

if(mark==0)cout"请先从文件中读取信息!"endl;

else

{

first_function(HuffNode,HuffCode,total,message);

writing_HCode(HuffNode,HuffCode,total);//将编码规则写进文件

}

break;

case 5://将编码后的信息写进文件

if(mark==0)cout"请先从文件中读取信息!"endl;

else

{

first_function(HuffNode,HuffCode,total,message);

writing_lock(locking);//将已编码信息写进文件

}

break;

case 6://将译码后的信息写进文件

if(mark==0)cout"请先从文件中读取信息!"endl;

else

{

first_function(HuffNode,HuffCode,total,message);

writing_translate(locking,HuffCode,HuffNode,total);//将已编码信息翻译过来并写进文件

}

break;

}

}

/**

打印haffman树

**/

display(total,HuffNode);

system("PAUSE");

return 0;

}

void display(Total *total,HNodetype HuffNode[])

{

int i,j;

for(i=0;i2*total-num-1;i++)

{

printf("data weight lchild rchild parent \n");

printf(" %c %d %d %d %d\n",HuffNode[i].data,HuffNode[i].weight,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].parent);

}

}

void reading_file(Message *message)

/**

绝对路径下读取a_test.txt file

message 中的num记录suoyou字符总数 ，放在nes【】中

equal to the buffer

**/

{

int i=0;

char ch;

ifstream infile("a_test.txt",ios::in | ios::out);

if(!infile)//打开失败则结束

{

cout"打开a_test.txt文件失败"endl;

exit(1);

}

else

cout"读取文件成功"endl;

while(infile.get(ch) ch!='#')//读取字符直到遇到#

{

message-mes[i]=ch;

i++;

}

message-num=i;//记录总字符数

infile.close();//关闭文件

}

int writing_file(Message *message)

/**

把从数组message 的信息write to disk，a_test1.txt to save

**/

{ /*

int i;

ifstream outfile("a_test1.txt",ios::in ); //打开文件

if( !outfile )//打开失败则结束

{

cout"打开a_test1.txt文件失败"endl;

return -1;

}

for(i=0;imessage-num;i++)//写文件

outfile.put(message-mes[i]);

cout"信息写进文件成功"endl;

outfile.close();//关闭文件

return 0;*/

int i;

FILE *fp1=NULL;

if((fp1 = fopen("a_test1.txt","at"))==NULL)

{

printf("can't open the file\n");

exit(0);

}

for(i=0;imessage-num;i++)

fprintf(fp1,"%d ",message-mes[i]);

printf("文件写入成功!\n");

i=fclose(fp1);

if(i==0)

printf("文件关闭成功!\n");

else

printf("文件关闭失败!\n");

}

void total_message(Message *message,Total *total)

/**

统计message中不同字符 的个数，和相同字符重复的次数，重复字符用mark标记，

total.tot[] 放不同字符，TotalNode 类型（char，num）

total.num 统计不同字符个数

使total这块内存空间有数据，

**/

{

int i,j,mark;

for(i=0;imessage-num;i++)//遍历message中的所有字符信息

{

if(message-mes[i]!=' ')//字符不为空格时

{

mark=0;

for(j=0;jtotal-num;j++)//在total中搜索当前字符

if(total-tot[j].data==message-mes[i])//搜索到，则此字符次数加1，mark标志为1

{

total-tot[j].num++;

mark=1;

break;

}

if(mark==0)//未搜索到，新建字符种类，保存进total中，字符类加1

{

total-tot[total-num].data=message-mes[i];

total-tot[total-num].num=1;

total-num++;

}

}

}

}

void HaffmanTree(Total *total,HNodetype HuffNode[])

/**create the haffman tree

不同字符个数为叶子节点个数对应书上的n，

相同字符的个数为其权值weight；

get HuffNode to store the tree

**/

{

int i,j,min1,min2,x1,x2;

for(i=0;i2*(total-num)-1;i++)//初始化哈夫曼树并存入叶子结点权值和信息

{

if(i=total-num-1)

HuffNode[i].data=total-tot[i].data;

HuffNode[i].weight=total-tot[i].num;

HuffNode[i].parent=-1;

HuffNode[i].lchild=-1;

HuffNode[i].rchild=-1;

}

for(i=0;itotal-num-1;i++)

{

min1=min2=MAXVALUE;

x1=x2=0;

for(j=0;jtotal-num+i;j++)//选取最小x1和次小x2的两权值

{

if(HuffNode[j].parent==-1HuffNode[j].weightmin1)

{

min2=min1;

x2=x1;

min1=HuffNode[j].weight;

x1=j;

}

else

if(HuffNode[j].parent==-1HuffNode[j].weightmin2)

{

min2=HuffNode[j].weight;

x2=j;

}

}

HuffNode[x1].parent=total-num+i;//修改亲人结点位置

HuffNode[x2].parent=total-num+i;

HuffNode[total-num+i].weight=HuffNode[x1].weight+HuffNode[x2].weight;

HuffNode[total-num+i].lchild=x1;//左孩子比右孩子权值小

HuffNode[total-num+i].rchild=x2;

}

}

void HaffmanCode(HNodetype HuffNode[],HCodetype HuffCode[],Total *total)

/***

haffman to code (0,10,110,)

得到每个不同字符（叶子）的编码，

存贮在数组HuffCode【】中,bit[] store the char,start store the loction

**/

{

int i,j,c,p;

HCodetype cd;

for(i=0;itotal-num;i++)//建立叶子结点个数的编码

{

cd.start=total-num-1;//起始位初始化

p=HuffNode[i].parent;

c=i;

while(p!=-1)//从叶结点向上爬直到到达根结点

{

if(HuffNode[p].lchild==c)//左分支则为0

cd.bit[cd.start]=0;

else

cd.bit[cd.start]=1;//右分支则为1

cd.start--;//起始位向前移动

c=p;

p=HuffNode[p].parent;

}

for(j=cd.start+1;jtotal-num;j++)//保存求出的每个叶结点编码和起始位

HuffCode[i].bit[j]=cd.bit[j];

HuffCode[i].start=cd.start;

}

}

void writing_HCode(HNodetype HuffNode[],HCodetype HuffCode[],Total *total)

/**

HuffNode[]to input the leaf

HuffCode[]to input the code

all is to the a_test2.txt ,save the code

**/

{

/*打开HCode文件，失败则结束。将信息写进文件*/

int i,j;

FILE *fp2=NULL;

if((fp2 = fopen("a_test2.txt","at"))==NULL)

{

printf("can't open the file\n");

exit(0);

}

for(i=0;itotal-num;i++)

{fprintf(fp2,"%d ",HuffNode[i].data);

printf(" ");

for(j=HuffCode[i].start+1;jtotal-num;j++)

fprintf(fp2,"%d ",HuffCode[i].bit[j]);

}

printf("编码规则写进文件成功!\n");

i=fclose(fp2);

if(i==0)

printf("文件关闭成功!\n");

else

printf("文件关闭失败!\n");

}

void lock(Message *message,HNodetype HuffNode[],HCodetype HuffCode[],Total *total,Locking *locking)

/***

对messag操作，对所有字符加密，

结果存贮在数组locked[]中，locking 记录已经加密后的密文

**/

{

int i,j,m;

for(i=0;imessage-num;i++)//把相同的不同的字符全部 遍历

{

if(message-mes[i]==' ')//碰到空格则以-1形式保存进locked数组中

{

locking-locked[locking-num]=-1;

locking-num++;

}

else

for(j=0;jtotal-num;j++)//从total中找到对应的字符

{

if(HuffNode[j].data==message-mes[i])

//找到在HuffNode 中对应字符，找到下标j

// 在HuffCode

for(m=HuffCode[j].start+1;mtotal-num;m++)///////// !

{

locking-locked[locking-num]=HuffCode[j].bit[m];//加密

locking-num++;

}

}

}

}

void writing_lock(Locking *locking)

/*

将密文写到a_test3.txt

*/

{

int i;

FILE *fp3=NULL;

if((fp3= fopen("a_test3.txt","at"))==NULL)

{

printf("can't open the file\n");

exit(0);

}

for(i=0;ilocking-num;i++)

{

if(locking-locked[i]==-1)

printf(" ");

else

fprintf(fp3,"%d ",locking-locked[i]);

}

printf("已编码信息写进文件成功!\n");

i=fclose(fp3);

if(i==0)

printf("文件关闭成功!\n");

else

printf("文件关闭失败!\n");

}

void writing_translate(Locking *locking,HCodetype HuffCode[],HNodetype HuffNode[],Total *total)

/**

密文翻译成明文，然后存到文件 a_test4.txt

**/

{

int i,j,mark[100],start[100],min,max;

FILE *fp4=NULL;

if((fp4 = fopen("a_test4.txt","at"))==NULL)

{

printf("can't open the file\n");

exit(0);

}

for(i=0;itotal-num;i++)//start数组初始化

{

start[i]=HuffCode[i].start+1;//。。。。

}

for(i=0;itotal-num;i++)//mark数组初始化

{

mark[i]=1;

}

min=0;

for(max=0;maxlocking-num;max++)//写文件

{

if(locking-locked[max]==-1)//碰到空格信息则直接输出空格

{

printf(" ");//把空格写到文件

min++;

}

else

{

for(i=min;i=max;i++)//查找从min开始到max的编码对应的信息

{

for(j=0;jtotal-num;j++)

{

if(start[j] == total-num+1)

mark[j]=0; //对应编码比所给编码短则不在比较

if(mark[j]==1locking-locked[i]==HuffCode[j].bit[start[j]])

start[j]++;

else

mark[j]=0;

}

}

for(i=0;itotal-num;i++)//找到对应信息，则写进文件

{

if(mark[i]==1start[i]==total-num)

{

fprintf(fp4,"%d ",HuffNode[i].data);//写到文件outfile

break;

}

}

if(i!=total-num)

min=max+1;

for(i=0;itotal-num;i++)//start数组初始化

{

start[i]=HuffCode[i].start+1;

}

for(i=0;itotal-num;i++)//mark数组初始化

{

mark[i]=1;

}

}

}

printf("文件写入成功!\n");

i=fclose(fp4);

if(i==0)

printf("文件关闭成功!\n");

else

printf("文件关闭失败!\n");

}

void first_function(HNodetype HuffNode[],HCodetype HuffCode[],Total *total,Message *message)

{

total_message(message,total);//统计信息中各字符的出现次数

HaffmanTree(total,HuffNode);//构建哈夫曼树

HaffmanCode(HuffNode,HuffCode,total);//建立哈夫曼编码

}

golang中compress/flate包

官方标准库对flate包的定义是：flate包实现了deflate压缩数据格式，参见 RFC 1951 。gzip包和zlib包实现了对基于deflate的文件格式的访问。

这边什么是deflate？

维基百科给出的解释是： DEFLATE 是同时使用了 LZ77 算法与 哈夫曼编码 （Huffman Coding）的一个 无损数据压缩 算法 。它最初是由 菲尔·卡茨 （Phil Katz）为他的 PKZIP 软件第二版所定义的，后来被 RFC 1951 标准化。

1）func NewReader(r io.Reader) io.ReadCloser

2）func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser

3）func NewWrite(w io.Write, level int) (*Write, error)

4）func NewWriteDict(w io.Writer, level int, dict []byte) (*Writer, error)

5）func (e InternalError) Error() string

6）func (e *ReadError) Error() string

7）func (e *WriteError) Error() string

8）func (w *Writer) Close() error

9）func (w *Writer) Flush() error

9）func (w *Writer) Reset(dst io.Writer)

10）func (w *Writer) Write(data []byte) (n int, err error)

非常好的一个资源链接：

如果有很好的资源，欢迎在评论区留言分享