数据结构Huffman编码译码

1 .需求分析

 1.1问题描述

•          问题描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。

 

 1.2基本要求

 (1) 输入的形式和输入值的范围；

 (2) 输出的形式；

 (3) 程序所能达到的功能。

1.基本要求

（1）初始化（Initialzation）。从数据文件DataFile.data中读入字符及每个字符的权值，建立哈夫曼树HuffTree；

（2）编码（EnCoding）。用已建好的哈夫曼树，对文件ToBeTran.data中的文本进行编码形成报文，将报文写在文件Code.txt中；

（3）译码（Decoding）。利用已建好的哈夫曼树，对文件CodeFile.data中的代码进行解码形成原文，结果存入文件Textfile.txt中；

（4）输出（Output）。输出DataFile.data中出现的字符以及各字符出现的频度（或概率）；输出ToBeTran.data及其报文Code.txt；输出CodeFile.data及其原文Textfile.txt；

 

2. 概要设计

说明本程序中用到的所有抽象数据类型的定义。主程序的流程以及各程序模块之间的层次(调用)关系。 

(1) 数据结构 

哈夫曼树的节点

struct huff

{

    intweight;

    intparent;

    intl;

    intr;

};

哈夫曼编码的存储

struct huff *hufftree;

 

(2) 程序模块

选择1到i-1中parent为0且权值最小的两个下标

void Select(struct huff *HT, int n, int&s1, int &s2)

构建哈夫曼树：

void huffmancoding(struct huff *ht,int *w,intn)

对原文进行编码：

void code(char *c)

根据报文找到原文：

void decoding(char *zifu)

3. 详细设计

    核心技术分析：

1：构建哈夫曼树及生成哈夫曼编码：

 根据每个字符权值不同，根据最优二叉树的构建方法，递归生成哈夫曼树，并且用数组存放哈夫曼树。

再从每一叶子节点向树根遍历，求得编码

例如：

如图所示的四个节点v1，v2，v3，v4，他们的权值分别为7，11,4,5

       7          11         4         5

 

 

第一步：选择两个权值最小的节点作为左右子孩子，建立一个二叉树，双亲权值为两个自孩子之和，如图

     7           11         9

 

 

 

 

 

重复第一步：

             11                    16

 

 

 

 

 

 

 

 

                              27

重复第一步：

                    16

 

 

 

 

 

 

 

 

则此时建立的是优有二叉树，约定定左子树边编码为1，右子树编码为0，则可以对次二叉树进行编码，如图：

 

 

 

                    

                   1            0

 

                               1             0

 

 

 

                                          1           0

 

 

 

则各顶点的编码为：

V1  01

V2  1

V3  001

V4  000

2：将原文编码：

逐个从文件读入字符，根据已经建立好的哈夫曼树，找到每一字符对应的编码

3：将报文译码：

步骤一：

先读入一个字符，存入匹配字符串

步骤二：

根据匹配串找所有的哈夫曼编码，如果找到对应的编码，则输入该编码所对应的字符，如果找不到，则读入两个字符存入匹配串，重复步骤二，找到为止。

步骤三：

把剩下的字符重复步骤一二

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct huff
{
    int weight;
    int parent;
    int l;
    int r;
};
int mm;/*记录哈夫曼字码的个数*/
struct huff *hufftree;
char **huffmancode;
void Select(struct huff *HT, int n, int &s1, int &s2)//选择函数，选出parent为零，且权值最小的两个节点
{
 int min1=100;
 int min2=100;
 int i;
 for(i=1;i<=n;i++)
        if((min1>HT[i].weight)&&(HT[i].parent==0))
        min1=HT[i].weight;
    for(i=1;i<=n;i++)
    if((min1==HT[i].weight)&&(HT[i].parent==0))
    {
        s1=i;
        break;
    }
    for(i=1;i<=n;i++)
        if((min2>HT[i].weight)&&(HT[i].parent==0)&&(i!=s1))
        min2=HT[i].weight;
    for(i=1;i<=n;i++)
    if((min2==HT[i].weight)&&(HT[i].parent==0)&&(i!=s1))
    {
        s2=i;
        break;
    }
}
int pipei(char *c)/*在huffmancode寻找匹配的编码*/
{
    int i;
    for(i=1;i<mm;i++)
    {
        if(strcmp(c,huffmancode[i])==0)
        {
            return i;
            break;
        }
    }
    return 0;
}
void decoding(char *zifu)/*对哈夫曼编码进行译码*/
{
    FILE *fp,*fp1;
    int i,j,p,ii;
    int n;
    char c[11];
    for(i=0;i<10;i++)
        c[i]='\0';
        printf("codefile.txt报文为：\n");
    if((fp=fopen("codefile.txt","r"))==NULL)
    {
        printf("error\n");
    }
    char a[100];
    for(i=1;;i++)
    {
    fscanf(fp,"%c",&a[i]);
    if(a[i]=='#')
        break;
        printf("%c",a[i]);
    }
    printf("\n");
    fclose(fp);
    if((fp1=fopen("testfile.txt","w"))==NULL)
    {
        printf("error\n");
    }
    i=1;
    j=1;
    int m=1;
    printf("对应原文为\n");
    while(true)
    {
        if(a[m]=='#')
            break;
        for(j=0;j<i;j++)
        {
            c[j]=a[m+j];
        }
        n=pipei(c);
        if(n!=0)
        {
            fprintf(fp1,"%c",zifu[n]);
            printf("%c",zifu[n]);
            m=m+i;
            i=1;
        }
        else
            i++;
        for(ii=0;ii<10;ii++)
        c[ii]='\0';
    }
    printf("\n");
    fclose(fp1);
}
int main()
{
     system("color e0"); //可以写成 red 调出颜色组
     system("title huffman系统"); //设置cmd窗口标题

     system("date /T");
     system("TIME /T");
    void huffmancoding(struct huff *ht,int *w,int n);
    void code(char *c);
    int i;
    FILE *fp,*fp1,*fp2;
    if((fp=fopen("DataFile.txt","r"))==NULL)
    {
        printf("error\n");
    }
    int w[28];
     char c[28];
     printf("从文件DataFile.txt读入字符和权值分别为：\n");
    for(i=1;;i++)
    {
        fscanf(fp,"%c",&c[i]);
        if(c[i]=='#')
            break;
        fscanf(fp,"%d",&w[i]);
        printf("%c: ",c[i]);
        printf("%d\n",w[i]);
    }
    fclose(fp);
    int m=i-1;
    mm=i;
     huffmancode=(char **)malloc(i*sizeof(char *));
    huffmancoding(hufftree,w,m);
    printf("各字符的编码为\n");
    for(i=1;i<=m;i++)
    {
        printf("%c: ",c[i]);
        printf("%s\n",huffmancode[i]);
    }
    code(c);
    decoding(c);
    return 0;
}
void code(char *c)/*根据原文进行编码*/
{
    FILE *fp,*fp1;
    int i,j;
    char a[100];
    printf("tobetran.txt原文为：\n");
    if((fp=fopen("tobetran.txt","r"))==NULL)
    {
        printf("error\n");
    }
        for(i=1;;i++)
        {

             fscanf(fp,"%c",&a[i]);
               if(a[i]=='#')
             {
             printf("\n");
                 break;
             }
              printf("%c ",a[i]);
        }
         fclose(fp);
    if((fp1=fopen("code.txt","w"))==NULL)
    {
        printf("error\n");
    }
    printf("对应报文为：\n");
    for(i=1;;i++)
    {
        if(a[i]=='#')
            break;
        for(j=1;j<=26;j++)
        {
            if(a[i]==c[j])
            {
                fprintf(fp1,"%s",huffmancode[j]);
                printf("%s",huffmancode[j]);
                break;
            }
        }
    }
    printf("\n");
        fclose(fp1);
}
void huffmancoding(struct huff *ht,int *w,int n)/*构建哈夫曼树和哈夫曼编码*/
{

    if(n<=1)
        return;
    int m,i;
    m=2*n-1;
    ht=(struct huff *)malloc((m+1)*sizeof(struct huff));
    struct huff *p;
    for(p=ht,i=0;i<=n;i++,p++,w++)
    {
        p->weight=*w;
        p->parent=0;
        p->l=0;
        p->r=0;
    }
    for(;i<=m;i++,p++)
    {
        p->l=0;
        p->weight=0;
        p->parent=0;
        p->r=0;
            }
    for(i=1;i<=4;i++)
    for(i=n+1;i<=m;i++)
    {
        int s1,s2;
        Select(ht,i-1,s1,s2);
        ht[s1].parent=i;
        ht[s2].parent=i;
        ht[i].l=s1;
        ht[i].r=s2;
        ht[i].weight=ht[s1].weight+ht[s2].weight;
    }

    char *cd;
    cd=(char *)malloc(n*sizeof(char));
    cd[n-1]='\0';
    int start,c,f;
    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].l==c)
            cd[--start]='0';
        else
            cd[--start]='1';
            huffmancode[i]=(char *)malloc((n-start)*sizeof(char));
            strcpy(huffmancode[i],&cd[start]);
    }
     free(cd);
}