C語言之霍夫曼編碼學習

szjxlyj發表於2015-01-09
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五個字母中每個字母的出現頻率，將最小的兩個字母頻率相加合成一個新的節點。如上圖所示，發現F與O的頻率最小，故相加2+3=5，將F、O組成一個樹，F為左節點，O為右節點，（FO）為根節點，每個節點的取值為其出現頻率（FO的出現頻率為5）

3、比較5.R.G.E.T，發現R與G的頻率最小，故相加4+4=8，將RG組成一個新的節點

4、比較5.8.E.T，發現5與E的頻率最小，故相加5+5=10，因此將FO作為左節點，E作為右節點，FOE作為根節點

5、比較8.10.T，發現8與T的頻率最小，故相加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 //哈夫曼編碼的最大位數


  8. //定義結構體
  9. typedef struct FrequencyTreeNode {
  10.     int freq;
  11.     char c;
  12.     struct FrequencyTreeNode *left;
  13.     struct FrequencyTreeNode *right;
  14. } FrequencyTreeNodeStruct, *pFrequencyTreeNodeStruct;


  17. FrequencyTreeNodeStruct frequencies[MAXALPABETNUM];


  20. typedef struct
  21. {
  22.      char bits[n]; //位串
  23.      int start; //編碼在位串中的起始位置
  24.      char ch; //字元
  25. }codetype;


  28. // 讀取檔案內容，統計字元以及出現頻率
  29. void readTxtStatistics(char* fileName)
  30. {
  31.     unsigned int nArray[52] = {0};
  32.     unsigned int i, j;
  33.     char szBuffer[MAXLINE];
  34.     int k=0;
  35.     // 讀取檔案內容
  36.     FILE* fp = fopen(fileName, \"r\");
  37.     if (fp != NULL)
  38.     { /*讀取檔案內容,先統計字母以及出現次數*/
  39.         while(fgets(szBuffer, MAXLINE, fp)!=NULL)
  40.         {
  41.             for(i = 0; i < strlen(szBuffer); i++)
  42.             {
  43.                 if(szBuffer[i] <= \'Z\' && szBuffer[i] >= \'A\')
  44.                 {
  45.                     j = szBuffer[i] - \'A\';
  46.                 }
  47.                 else if(szBuffer[i] <= \'z\' && szBuffer[i] >= \'a\')
  48.                 {
  49.                     j = szBuffer[i] - \'a\' + 26;
  50.                 }
  51.                 else
  52.                 continue;
  53.                 nArray[j]++;
  54.             }
  55.         }


  58.         // 然後賦值給frequencies陣列
  59.         for(i = 0, j = \'A\'; i < 52; i++, j++)
  60.         {
  61.             if (nArray[i] >0)
  62.             {
  63.             /*****/
  64.                 frequencies[k].c=j;
  65.                 frequencies[k].freq=nArray[i];
  66.                 frequencies[k].left=NULL;
  67.                 frequencies[k].right=NULL;
  68.                 k++;
  69.                 printf(\"%c:%d\\n\", j, nArray[i]);
  70.             }
  71.             if(j == \'Z\')
  72.                 j = \'a\' - 1;
  73.         }
  74.     }
  75. }


  78. //建立哈夫曼樹
  79. void huffMan(frequencies tree[]){
  80.     int i,j,p1,p2;//p1,p2分別記住每次合併時權值最小和次小的兩個根結點的下標
  81.     float small1,small2,f;
  82.     char c;
  83.     for(i=0;i<m;i++) //初始化
  84.     {
  85.          tree[i].parent=0;
  86.          tree[i].lchild=-1;
  87.          tree[i].rchild=-1;
  88.          tree[i].weight=0.0;
  89.     }
  90.      printf(\"【依次讀入前%d個結點的字元及權值(中間用空格隔開)】\\n\",n);


  93.     //讀入前n個結點的字元及權值
  94.     for(i=0;i<n;i++)
  95.     {
  96.         printf(\"輸入第%d個字元為和權值\",i+1);
  97.         scanf(\"%c %f\",&c,&f);
  98.         getchar();
  99.         tree[i].ch=c;
  100.         tree[i].weight=f;
  101.     }
  102.     //進行n-1次合併，產生n-1個新結點
  103.     for(i=n;i<m;i++)
  104.     {
  105.          p1=0;p2=0;
  106.          //maxval是float型別的最大值
  107.          small1=maxval;small2=maxval;
  108.          //選出兩個權值最小的根結點
  109.          for(j=0;j<i;j++)
  110.          {
  111.               if(tree[j].parent==0)
  112.               if(tree[j].weight<small1)
  113.                {
  114.                     small2=small1; //改變最小權、次小權及對應的位置
  115.                     small1=tree[j].weight;
  116.                     p2=p1;
  117.                     p1=j;
  118.                }
  119.                else if(tree[j].weight<small2)
  120.                 {
  121.                  small2=tree[j].weight; //改變次小權及位置
  122.                  p2=j;
  123.                 }
  124.                tree[p1].parent=i;
  125.                tree[p2].parent=i;
  126.                tree[i].lchild=p1; //最小權根結點是新結點的左孩子
  127.                tree[i].rchild=p2; //次小權根結點是新結點的右孩子
  128.                tree[i].weight=tree[p1].weight+tree[p2].weight;
  129.         }
  130.    }
  131. }


  134. //根據哈夫曼樹求出哈夫曼編碼，code[]為求出的哈夫曼編碼，tree[]為已知的哈夫曼樹
  135. void huffmancode(codetype code[],frequencies tree[])
  136. {
  137.      int i,c,p;
  138.      codetype cd; //緩衝變數
  139.      for(i=0;i<n;i++)
  140.      {
  141.           cd.start=n;
  142.           cd.ch=tree[i].ch;
  143.           c=i; //從葉結點出發向上回溯
  144.           p=tree[i].parent; //tree[p]是tree[i]的雙親
  145.           while(p!=0)
  146.           {
  147.                cd.start--;
  148.                if(tree[p].lchild==c)
  149.                     cd.bits[cd.start]=\'0\'; //tree[i]是左子樹，生成程式碼\'0\'
  150.                else
  151.                     cd.bits[cd.start]=\'1\'; //tree[i]是右子樹，生成程式碼\'1\'
  152.                c=p;
  153.                p=tree[p].parent;
  154.           }
  155.           code[i]=cd; //第i+1個字元的編碼存入code[i]
  156.      }
  157. }




  162. //根據哈夫曼樹解碼
  163. void decode(hufmtree tree[])
  164. {
  165.      int i,j=0;
  166.      char b[maxsize];
  167.      char endflag=\'2\'; //電文結束標誌取2
  168.      i=m-1; //從根結點開始往下搜尋
  169.      printf(\"輸入傳送的編碼(以\'2\'為結束標誌)：\");
  170.      gets(b);
  171.      printf(\"編碼後的字元為\");
  172.      while(b[j]!=\'2\')
  173.      {
  174.           if(b[j]==\'0\')
  175.            i=tree[i].lchild; //走向左子節點
  176.           else
  177.            i=tree[i].rchild; //走向右子節點
  178.           if(tree[i].lchild==-1) //tree[i]是葉結點
  179.           {
  180.              printf(\"%c\",tree[i].ch);
  181.              i=m-1; //回到根結點
  182.           }
  183.           j++;
  184.      }
  185.      printf(\"\\n\");
  186.      if(tree[i].lchild!=-1&&b[j]!=\'2\') //文字讀完，但尚未到葉子結點
  187.      printf(\"\\nERROR\\n\"); //輸入文字有錯
  188. }




  193. void main()
  194. {
  195.      printf(\"---------------—— 哈夫曼編碼實戰 ——\\n\");
  196.      printf(\"總共有%d個字元\\n\",n);
  197.      frequencies tree[m];
  198.      codetype code[n];
  199.      int i,j;//迴圈變數
  200.      huffMan(tree);//建立哈夫曼樹
  201.      huffmancode(code,tree);//根據哈夫曼樹求出哈夫曼編碼
  202.      printf(\"【輸出每個字元的哈夫曼編碼】\\n\");
  203.      for(i=0;i<n;i++)
  204.      {
  205.           printf(\"%c: \",code[i].ch);
  206.           for(j=code[i].start;j<n;j++)
  207.           printf(\"%c \",code[i].bits[j]);
  208.           printf(\"\\n\");
  209.      }
  210.      printf(\"【讀入內容，並進行編碼】\\n\");
  211.      // 開始編碼
  212.      decode(tree);
  213. }

----------------------------------------------------------------------------------------------------------------
有，文章允許轉載，但必須以連結方式註明源地址，否則追究法律責任!>
原部落格地址： http://blog.itpub.net/26230597/viewspace-1384144/
原作者：黃杉 (mchdba)
----------------------------------------------------------------------------------------------------------------



來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/30078170/viewspace-1396407/，如需轉載，請註明出處，否則將追究法律責任。

相關文章