数据结构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
#include
#include
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;iweight=*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);
}