首页 > 代码库 > C语言之霍夫曼编码学习

C语言之霍夫曼编码学习

  
?
1,霍夫曼编码描述

哈夫曼树─即最优二叉树,带权路径长度最小的二叉树,经常应用于数据压缩。 在计算机信息处理中,“哈夫曼编码”是一种一致性编码法(又称“熵编码法”),用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符(例如某文件中的一个符号)进行编码。这张编码表的特殊之处在于,它是根据每一个源字符出现的估算概率而建立起来的(出现概率高的字符使用较短的编码,反之出现概率低的则使用较长的编码,这便使编码之后的字符串的平均期望长度降低,从而达到无损压缩数据的目的)。这种方法是由David.A.Huffman发展起来的。 例如,在英文中,e的出现概率很高,而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时,e极有可能用一个位(bit)来表示,而z则可能花去25个位(不是26)。用普通的表示方法时,每个英文字母均占用一个字节(byte),即8个位。二者相比,e使用了一般编码的1/8的长度,z则使用了3倍多。若能实现对于英文中各个字母出现概率的较准确的估算,就可以大幅度提高无损压缩的比例。

2,问题描述
霍夫曼编码前首先要统计每个字的字频,即出现次数,例如:

技术分享


1、将所有字母出现的次数以从小到大的顺序排序,如上图

2、每个字母都代表一个终端节点(叶节点),比较F.O.R.G.E.T五个字母中每个字母的出现频率,将最小的两个字母频率相加合成一个新的节点。如上图所示,发现FO的频率最小,故相加2+3=5,将F、O组成一个树,F为左节点,O为右节点,(FO)为根节点,每个节点的取值为其出现频率(FO的出现频率为5)

3、比较5.R.G.E.T,发现RG的频率最小,故相加4+4=8,将RG组成一个新的节点

4、比较5.8.E.T,发现5E的频率最小,故相加5+5=10,因此将FO作为左节点,E作为右节点,FOE作为根节点

5、比较8.10.T,发现8T的频率最小,故相加8+7=15,将RG作为左节点,T作为右节点,RGT作为根节点

6、最后剩10.15,没有可以比较的对象,相加10+15=25,FOE作为左节点,RGT作为右节点


根节点不取值,每个左子节点取值0,右子节点取值1,将每个字母从根节点开始遍历,沿途的取值组成编码:

技术分享



首先选择一个文本,统计每个字符出现的次数,组成以下数组:
typedef struct FrequencyTreeNode {
    int freq;
    char c;
    struct FrequencyTreeNode *left;
    struct FrequencyTreeNode *right;
} FrequencyTreeNodeStruct, *pFrequencyTreeNodeStruct;

然后将获得的数组frequencies进行排序,按照freq由小到大的顺序组成一个二叉查找树,FrequencyTreeNodeStruct,从二叉查找树中找到最小的节点,从树中删除,再取最小的节点,两个子节点,组成一个新的树,根节点c为0,freq为两个子节点的和,加入frequencies中,并排序,重复该步骤,一直到frequencies中只有一个节点,则该节点为Huffman coding tree的根节点


以short类型按照前述的规则为每个字符编码,尔后将文本翻译为Huffman coding,再通过Huffman coding tree进行解码,验证编码的正确性。


3,代码实现

  1. #include<stdio.h>
  2. #define n 5 //叶子数目
  3. #define m (2*n-1) //结点总数
  4. #define maxval 10000.0
  5. #define maxsize 100 //哈夫曼编码的最大位数


  6. //定义结构体
  7. typedef struct FrequencyTreeNode {
  8.     int freq;
  9.     char c;
  10.     struct FrequencyTreeNode *left;
  11.     struct FrequencyTreeNode *right;
  12. } FrequencyTreeNodeStruct, *pFrequencyTreeNodeStruct;


  13. FrequencyTreeNodeStruct frequencies[MAXALPABETNUM];


  14. typedef struct
  15. {
  16.      char bits[n]; //位串
  17.      int start; //编码在位串中的起始位置
  18.      char ch; //字符
  19. }codetype;


  20. // 读取文件内容,统计字符以及出现频率
  21. void readTxtStatistics(char* fileName)
  22. {
  23.     unsigned int nArray[52] = {0};
  24.     unsigned int i, j;
  25.     char szBuffer[MAXLINE];
  26.     int k=0;
  27.     // 读取文件内容
  28.     FILE* fp = fopen(fileName, \"r\");
  29.     if (fp != NULL)
  30.     { /*读取文件内容,先统计字母以及出现次数*/
  31.         while(fgets(szBuffer, MAXLINE, fp)!=NULL)
  32.         {
  33.             for(= 0; i < strlen(szBuffer); i++)
  34.             {
  35.                 if(szBuffer[i] <= \Z\ && szBuffer[i] >= \A\)
  36.                 {
  37.                     j = szBuffer[i] - \A\;
  38.                 }
  39.                 else if(szBuffer[i] <= \z\ && szBuffer[i] >= \a\)
  40.                 {
  41.                     j = szBuffer[i] - \a\ + 26;
  42.                 }
  43.                 else
  44.                 continue;
  45.                 nArray[j]++;
  46.             }
  47.         }


  48.         // 然后赋值给frequencies数组
  49.         for(= 0, j = \A\; i < 52; i++, j++)
  50.         {
  51.             if (nArray[i] >0)
  52.             {
  53.             /*****/
  54.                 frequencies[k].c=j;
  55.                 frequencies[k].freq=nArray[i];
  56.                 frequencies[k].left=NULL;
  57.                 frequencies[k].right=NULL;
  58.                 k++;
  59.                 printf(\"%c:%d\\n\", j, nArray[i]);
  60.             }
  61.             if(== \Z\)
  62.                 j = \a\ - 1;
  63.         }
  64.     }
  65. }


  66. //建立哈夫曼树
  67. void huffMan(frequencies tree[]){
  68.     int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
  69.     float small1,small2,f;
  70.     char c;
  71.     for(i=0;i<m;i++) //初始化
  72.     {
  73.          tree[i].parent=0;
  74.          tree[i].lchild=-1;
  75.          tree[i].rchild=-1;
  76.          tree[i].weight=0.0;
  77.     }
  78.      printf(\"【依次读入前%d个结点的字符及权值(中间用空格隔开)】\\n\",n);


  79.     //读入前n个结点的字符及权值
  80.     for(i=0;i<n;i++)
  81.     {
  82.         printf(\"输入第%d个字符为和权值\",i+1);
  83.         scanf(\"%c %f\",&c,&f);
  84.         getchar();
  85.         tree[i].ch=c;
  86.         tree[i].weight=f;
  87.     }
  88.     //进行n-1次合并,产生n-1个新结点
  89.     for(i=n;i<m;i++)
  90.     {
  91.          p1=0;p2=0;
  92.          //maxval是float类型的最大值
  93.          small1=maxval;small2=maxval;
  94.          //选出两个权值最小的根结点
  95.          for(j=0;j<i;j++)
  96.          {
  97.               if(tree[j].parent==0)
  98.               if(tree[j].weight<small1)
  99.                {
  100.                     small2=small1; //改变最小权、次小权及对应的位置
  101.                     small1=tree[j].weight;
  102.                     p2=p1;
  103.                     p1=j;
  104.                }
  105.                else if(tree[j].weight<small2)
  106.                 {
  107.                  small2=tree[j].weight; //改变次小权及位置
  108.                  p2=j;
  109.                 }
  110.                tree[p1].parent=i;
  111.                tree[p2].parent=i;
  112.                tree[i].lchild=p1; //最小权根结点是新结点的左孩子
  113.                tree[i].rchild=p2; //次小权根结点是新结点的右孩子
  114.                tree[i].weight=tree[p1].weight+tree[p2].weight;
  115.         }
  116.    }
  117. }


  118. //根据哈夫曼树求出哈夫曼编码,code[]为求出的哈夫曼编码,tree[]为已知的哈夫曼树
  119. void huffmancode(codetype code[],frequencies tree[])
  120. {
  121.      int i,c,p;
  122.      codetype cd; //缓冲变量
  123.      for(i=0;i<n;i++)
  124.      {
  125.           cd.start=n;
  126.           cd.ch=tree[i].ch;
  127.           c=i; //从叶结点出发向上回溯
  128.           p=tree[i].parent; //tree[p]是tree[i]的双亲
  129.           while(p!=0)
  130.           {
  131.                cd.start--;
  132.                if(tree[p].lchild==c)
  133.                     cd.bits[cd.start]=\0\; //tree[i]是左子树,生成代码\0\
  134.                else
  135.                     cd.bits[cd.start]=\1\; //tree[i]是右子树,生成代码\1\
  136.                c=p;
  137.                p=tree[p].parent;
  138.           }
  139.           code[i]=cd; //第i+1个字符的编码存入code[i]
  140.      }
  141. }




  142. //根据哈夫曼树解码
  143. void decode(hufmtree tree[])
  144. {
  145.      int i,j=0;
  146.      char b[maxsize];
  147.      char endflag=\2\; //电文结束标志取2
  148.      i=m-1; //从根结点开始往下搜索
  149.      printf(\"输入发送的编码(以\‘2\‘为结束标志):\");
  150.      gets(b);
  151.      printf(\"编码后的字符为\");
  152.      while(b[j]!=\2\)
  153.      {
  154.           if(b[j]==\0\)
  155.            i=tree[i].lchild; //走向左子节点
  156.           else
  157.            i=tree[i].rchild; //走向右子节点
  158.           if(tree[i].lchild==-1) //tree[i]是叶结点
  159.           {
  160.              printf(\"%c\",tree[i].ch);
  161.              i=m-1; //回到根结点
  162.           }
  163.           j++;
  164.      }
  165.      printf(\"\\n\");
  166.      if(tree[i].lchild!=-1&&b[j]!=\2\) //文本读完,但尚未到叶子结点
  167.      printf(\"\\nERROR\\n\"); //输入文本有错
  168. }




  169. void main()
  170. {
  171.      printf(\"---------------—— 哈夫曼编码实战 ——\\n\");
  172.      printf(\"总共有%d个字符\\n\",n);
  173.      frequencies tree[m];
  174.      codetype code[n];
  175.      int i,j;//循环变量
  176.      huffMan(tree);//建立哈夫曼树
  177.      huffmancode(code,tree);//根据哈夫曼树求出哈夫曼编码
  178.      printf(\"【输出每个字符的哈夫曼编码】\\n\");
  179.      for(i=0;i<n;i++)
  180.      {
  181.           printf(\"%c: \",code[i].ch);
  182.           for(j=code[i].start;j<n;j++)
  183.           printf(\"%c \",code[i].bits[j]);
  184.           printf(\"\\n\");
  185.      }
  186.      printf(\"【读入内容,并进行编码】\\n\");
  187.      // 开始编码
  188.      decode(tree);
  189. }

----------------------------------------------------------------------------------------------------------------
<版权所有,允许转载,但必须以链接方式注明源地址,否则追究法律责任!>
原博客地址: http://blog.itpub.net/26230597/viewspace-1384144/
原作者:黄杉 (mchdba)
----------------------------------------------------------------------------------------------------------------



C语言之霍夫曼编码学习