2. 程式人生 > 實用技巧 >資料結構之哈夫曼編碼

資料結構之哈夫曼編碼

阿新 • • 發佈：2020-12-26

哈夫曼編碼是一種變長編碼，根據字元頻率確定編碼的長度。在學習資料結構時，我們知道，通過貪心的策略自底向上構造二叉樹，最後得到哈夫曼樹。從根節點遍歷，便可以得到編碼。

本文給出了經典教材《資料結構》一書上演算法6.12的具體實現細節。

目錄

型別定義

構造二叉樹的過程為：初始為全部字元的 \(n\) 個葉子節點，每次選擇權值最小的兩個根節點合併，形成新的節點，其權值為合併的兩節點權值之和。引入 parent 作為是否為根節點判斷的標誌。

\(n\) 個節點完成 \(n-1\) 次合併操作，形成共包含 \(2n-1\) 個節點的二叉樹，樹的根節點編號為 \(2n-1\)

。

// 哈夫曼樹節點型別 
typedef struct {
	char data;   // 節點字元
    double weight;   // 節點權值
    int parent, lchild, rchild;  // 父節點、左右孩子節點
}HfmTNode, *HuffmanTree;


// 哈夫曼編碼型別  記錄{字元 -> 編碼}
typedef struct {
    char letter;     // 節點字元
    char *code;      // 節點編碼
}HfmCNode, *HuffmanCode;

// 哈夫曼型別
typedef struct {
    HuffmanTree tree;
    HuffmanCode code;
    int n;          // 字符集長度
    char *letters;  // 字符集
    int *frequency; // 字元頻率
    int rt;         // 哈夫曼樹根節點編號，根節點即 `tree[2n-1]`
}Huffman;

程式碼實現

參考 《資料結構（C語言版）》

P147 演算法 6.12

哈夫曼編碼

要得到哈夫曼編碼，依次呼叫

  • initHuffman(hfm, letters, frequency, n);
  • buildHuffmanTree(hfm);
  • getHuffmanCode(hfm);
// 初始化哈夫曼
void initHuffman(Huffman *hfm, const char *letters, const int frequency[], int n)
{
    if (n<1) return;

    int m = 2*n-1;
    hfm->n = n;
    hfm->letters = (char*)malloc((n+1)*sizeof(char));
    hfm->frequency = (int*)malloc((n+1)*sizeof(int));
    hfm->tree = (HuffmanTree)malloc((m+1)* sizeof(HfmTNode));
    hfm->rt = m;

    for (int i=1;i<=n;i++)
    {
        hfm->letters[i] = letters[i-1];
        hfm->frequency[i] = frequency[i-1];
    }

    for (int i=1;i<=n;i++)
        hfm->tree[i] = (HfmTNode){letters[i-1], frequency[i-1], 0, 0, 0};
    for (int i=n+1;i<2*n;i++)
        hfm->tree[i] = (HfmTNode){0, 0, 0, 0, 0};

    for(int i=n+1;i<=m;i++)
    {
        hfm->tree[i].weight = 0;
        hfm->tree[i].lchild = hfm->tree[i].rchild = hfm->tree[i].parent = 0;
    }

}

// 建立哈夫曼樹
void buildHuffmanTree(Huffman *hfm)
{
    // 建立哈夫曼樹
    int n = hfm->n;
    int m = 2*n-1;
    for(int i=n+1;i<=m;i++)
    {
        int p1 = 1, p2 = 1;     // p1記錄最小結點位置， p2記錄第二小
        while(p1<=i-1 && hfm->tree[p1].parent) p1++;
        p2 = p1+1;
        while(p2<=i-1 && hfm->tree[p2].parent) p2++;

        for(int j=p1+1;j<=i-1;j++)
        {
            if (hfm->tree[j].parent) continue; // 非根節點

            if(hfm->tree[j].weight<=hfm->tree[p1].weight)
            {
                p2 = p1, p1 = j;
            }
            else if(hfm->tree[j].weight<hfm->tree[p2].weight)
            {
                p2 = j;
            }
        }

        hfm->tree[i].weight = hfm->tree[p1].weight + hfm->tree[p2].weight;
        hfm->tree[i].lchild = p1;  hfm->tree[i].rchild = p2;
        hfm->tree[p1].parent = i;  hfm->tree[p2].parent = i;
    }
}

// 獲取哈夫曼編碼
void getHuffmanCode(Huffman *hfm)
{
    // 求赫夫曼編碼
    int n = hfm->n;
    hfm->code = (HuffmanCode)malloc((n+1)*sizeof(HfmCNode));
    for (int i=1;i<=n;i++) hfm->code[i] = (HfmCNode){hfm->letters[i], ""};

    char *code = (char *)malloc(n*sizeof(char));
    code[n-1] = '\0';

    for(int i=1;i<=n;i++)
    {
        int start = n-1;
        int c = i, f = hfm->tree[i].parent;
        while(f)
        {
            if(c==hfm->tree[f].lchild)  code[--start] = '0';
            else  code[--start] = '1';

            c = f;  f = hfm->tree[c].parent;
        }
        
        hfm->code[i].code = (char*)malloc((n-start)*sizeof(char));
        strcpy(hfm->code[i].code, &code[start]);
    }
    free(code);
}

// 凹入表示法輸出
void showHuffmanTree(Huffman *hfm, int rt=-1, int level=0)
{
    if (rt==0) return ;
    if (rt==-1)
    {
        printf("HuffmanCode:\n");
        for (int i=1;i<=hfm->n;i++)
        {  
            // printf("%c\n", hfm->letters[i]);
            // printf("%c\n", hfm->tree[i].data);
            printf("%c:%s\n", hfm->code[i].letter, hfm->code[i].code);
        }
        rt = hfm->rt;
        printf("HuffmanTree:\n");
    }

    int i;
    for(i=0;i<level;i++) printf("  ");

    if (hfm->tree[rt].data==0)
        printf("**\n");
    else
        printf("%c:%s\n", hfm->tree[rt].data, hfm->code[rt].code);

    
    showHuffmanTree(hfm, hfm->tree[rt].lchild, level+1);
    showHuffmanTree(hfm, hfm->tree[rt].rchild, level+1);
}

編碼與譯碼

圖方便，直接使用了C++ string型別，而不是基於C型別字串（本質上是 char*字元陣列）

// 編碼
string Encode(Huffman *hfm, const char *input)
{
    int cnt = 0;
    string output = "";
    for (int i=0;input[i];i++)
    {
        char c = input[i];
        for (int i=1;i<=hfm->n;i++)
        {
            if (hfm->code[i].letter==c)
            {
                output += hfm->code[i].code;
                break;
            }

        }
        if (++cnt<=10)
            cout<<output<<endl;
    }

    return output;
}

// 譯碼
string Decode(Huffman *hfm, const char *input)
{
    int p = hfm->rt;
    string output = "";

    for (int i=0;input[i];i++)
    {
        char c = input[i];
        if(c=='0')  p = hfm->tree[p].lchild;
        else p = hfm->tree[p].rchild;

        if(p<=hfm->n)  // 翻譯到葉子節點
        {
            output += hfm->tree[p].data;
            p = hfm->rt;
        }
    }

    return output;
}

功能測試

// 統計文章字元頻率 建立哈夫曼樹
void readTxt2Huffman(const char *filename, Huffman *hfm)
{
    FILE *fp = fopen(filename, "r");
    if (fp==NULL) return;

    char *letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ,.;\'\""; 
    int frequency[58] = {0};  // 2*26個字母 空格 逗號 句號 分號 單引號 雙引號

    while(1)
    {
        char c = fgetc(fp);
        if (feof(fp))
            break;

        // if (c>='a' && c<='z') c += 'A' - 'a';
        if (c>='a' && c<='z') frequency[c-'a']++;
        else if (c>='A' && c<='Z') frequency[c-'A'+26]++;
        else if (c==' ') frequency[52]++;
        else if(c==',')  frequency[53]++;
        else if(c=='.')  frequency[54]++;
        else if(c==';')  frequency[55]++;
        else if(c=='\'')  frequency[56]++;
        else if(c=='\"')  frequency[57]++;

        // else printf("%c\n", c);
    }


    initHuffman(hfm, letters, frequency, 58);
    buildHuffmanTree(hfm);    
    getHuffmanCode(hfm);
}

// 讀檔案，返回char*字串
char* readText(const char* filename)
{
    char* text;
    FILE *pf = fopen(filename, "r");
    if (pf==NULL)
    {
        printf("檔案%s不存在\n", filename);
        return "";
    }

    fseek(pf, 0, SEEK_END);
    long lSize = ftell(pf);
    text = (char*)malloc(lSize+1);

    rewind(pf); 
    fread(text, sizeof(char), lSize, pf);
    text[lSize] = '\0';
    return text;
}

int main()
{
    /*  
	Huffman hfm;
    int w[6] = {1, 2, 3, 4, 6, 8};
    
    initHuffman(&hfm, "abcdef", w, 6);
    buildHuffmanTree(&hfm);    
    getHuffmanCode(&hfm);
    
    for (int i=1;i<=6;i++)
    {  
        printf("%c\n", hfm.letters[i]);
        printf("%c\n", hfm.tree[i].data);
        printf("%s\n", hfm.code[i].code);
    }

    showHuffmanTree(&hfm);

    cout<<Encode(&hfm, "bacbefd")<<endl;
    cout<<Decode(&hfm, "100110001011001011100")<<endl;
    */
   

    // 測試讀檔案，完成編碼，譯碼
    const char *filename = "article.txt";
    Huffman hfm;
    readTxt2Huffman(filename, &hfm);
    showHuffmanTree(&hfm);

    char text[5000];
    strcpy(text, readText(filename));
    // printf("加密前:\n");
    // printf("%s\n", text);
  
    // printf("加密後:\n");
    string text_encode = Encode(&hfm, text);
    cout<<text_encode<<endl;
    cout<<Decode(&hfm, text_encode.c_str())<<endl;
    
    return 0;
}

問題紀錄

  1. 任務一需要從控制檯讀入 需要按Ctrl Z終止輸入 用 2==scanf()跳出迴圈

  2. 分配記憶體使用malloc，單塊記憶體大小為 sizeof(xxx) 寫錯了型別，導致程式無輸出也沒有報錯，花費很長時間才定位到錯誤

    hfm->code = (HuffmanCode)malloc((n+1)*sizeof(HfmCNode))

  3. 讀取文章能正常建立哈夫曼樹並編碼 ，譯碼過程出錯。通過輸出譯碼過程，檢查到字符集（包含小寫）與譯碼規則不一致，需要對大小寫特判。完善字符集，包含大小寫和各種符號的字符集作為輸入，便可直接譯碼得到原始輸入。

小結

本人學習《資料結構》這門課是在大一C語言剛結束之後，彼時對C語言的核心——指標還沒完全琢磨透徹。學習資料結構也僅僅按部就班完成了書上的課程實驗，現在回頭看過去寫的程式碼，不僅程式碼風格凌亂，也存在記憶體洩漏的隱患。本次幫學弟寫作業的同時，順便重構了過去的程式碼。最近需要用C/C++進行k-means的演算法優化，也藉此好好熟悉一番傳統的C/C++。

（完）

相關推薦

資料結構之哈夫曼編碼

哈夫曼編碼是一種變長編碼，根據字元頻率確定編碼的長度。在學習資料結構時，我們知道，通過貪心的策略自底向上構造二叉樹，最後得到哈夫曼樹。從根節點遍歷，便可以得到編碼。

資料結構之哈夫曼樹

一、哈夫曼樹的基本概念 也叫最優二叉樹 1.引子： 將很多學生的百分制成績轉化為五分製成績<60: D      60-69: D     70-79:C    80-89:B       90-100:A

貪心演算法之哈夫曼編碼（基於榮政版資料結構與演算法分析）

特別注意一下哈夫曼編碼≠哈夫曼樹，相反，哈夫曼編碼裡面的不等長編碼的構造使用的就是哈夫曼樹

資料結構(c)--哈夫曼樹解碼

哈夫曼樹解碼 題目: 哈夫曼樹 圖 (從網上找的一張圖...) 1.權重值越小的結點就在最下面 比如圖中的B、C

資料結構09 哈夫曼樹

這一篇要總結的是樹中的哈夫曼樹(Huffman Tree)，我想從以下幾點對其進行總結：

10: java資料結構和演算法: 構建哈夫曼樹, 獲取哈夫曼編碼, 使用哈夫曼編碼原理對檔案壓縮和解壓

最終結果哈夫曼樹,如圖所示: 直接上程式碼: public class HuffmanCode { public static void main(String[] args) {

Python描述資料結構學習之哈夫曼樹篇

前言 本篇章主要介紹哈夫曼樹及哈夫曼編碼，包括哈夫曼樹的一些基本概念、構造、程式碼實現以及哈夫曼編碼，並用Python實現。

2020資料結構小學期（二）——哈夫曼編碼演算法

2、哈夫曼編碼演算法 輸入：字元及其權值，待譯碼字串，待解碼字串 功能要求：輸出各字元的哈夫曼編碼，輸出譯碼字串，輸出解碼字串

【資料結構與演算法基礎】哈夫曼樹與哈夫曼編碼(C++)

此文轉載自：https://blog.csdn.net/wayne_lee_lwc/article/details/109908756 前言 資料結構，一門資料處理的藝術，精巧的結構在一個又一個演算法下發揮著他們無與倫比的高效和精密之美，在為資訊科技打下堅實

20192313 2020-2021-1 《資料結構與面向物件程式設計》 哈夫曼編碼實踐報告

實踐內容 設有字符集：S={a,b,c,d,e，f,g,h,i,j,k,l,m,n.o.p.q,r,s,t,u,v,w,x,y,z}。 給定一個包含26個英文字母的檔案，統計每個字元出現的概率，根據計算的概率構造一顆哈夫曼樹。

20192328牛梓萌 2019-2020-1 《資料結構與面向物件程式設計》哈夫曼編碼實踐

20192328牛梓萌 2019-2020-1 《資料結構與面向物件程式設計》哈夫曼編碼實踐 課程：《程式設計與資料結構》

哈夫曼編碼—資料壓縮與解壓（Java）

哈夫曼編碼—資料壓縮與解壓（Java） 部落格說明 文章所涉及的資料來自網際網路整理和個人總結，意在於個人學習和經驗彙總，如有什麼地方侵權，請聯絡本人刪除，謝謝！

C++實現哈夫曼編碼

本文例項為大家分享了C++實現哈夫曼編碼的具體程式碼，供大家參考，具體內容如下

C語言實現哈夫曼編碼

本文例項為大家分享了C語言實現哈夫曼編碼的具體程式碼，供大家參考，具體內容如下

哈夫曼樹及哈夫曼編碼

哈夫曼樹及哈夫曼編碼 哈夫曼樹 基本介紹 給定n個葉子結點 ，構造一棵二叉樹。若該樹的帶權路徑長度（wpl）達到最值，則稱這棵樹為最有二叉樹，也稱為哈夫曼樹。

POJ1521(哈夫曼編碼)(貪心+優先佇列)

地址：http://poj.org/problem?id=1521 題意： 就是給定一個串，求原長度和哈夫曼編碼後的長，並求比值

哈夫曼編碼—檔案的壓縮與解壓（Java）

哈夫曼編碼—檔案的壓縮與解壓（Java） 部落格說明 文章所涉及的資料來自網際網路整理和個人總結，意在於個人學習和經驗彙總，如有什麼地方侵權，請聯絡本人刪除，謝謝！

哈夫曼編碼演算法

輸入：字元及其權值，待譯碼字串，待解碼字串 功能要求：輸出各字元的哈夫曼編碼，輸出譯碼字串，輸出解碼字串

哈夫曼編碼的一個實際應用

介紹: 本問題是來自於課堂上老師關於貪心問題的第三講.Huffman編碼是最有效的二進位制編碼,其中貪心策略主要體現在根據頻度來設定編碼長度.最早在資料結構的便有學習到,當時採用的建樹方式是帶指標的結構體+小頂堆(使

實驗——樹（根據後序和中序遍歷輸出先序遍歷、哈夫曼編碼）

實驗——樹（根據後序和中序遍歷輸出先序遍歷、哈夫曼編碼） 一、實驗目的