2. 程式人生 > >Huffman樹與編碼

Huffman樹與編碼

阿新 • • 發佈：2017-06-06
reat 指針數組 get n-1 include 開始 靜態數組 當前 編碼

帶權路徑最小的二叉樹稱為最優二叉樹或Huffman（哈夫曼樹）。

Huffman樹的構造

將節點的權值存入數組中，由數組開始構造Huffman樹。初始化指針數組，指針指向含有權值的孤立節點。

b = malloc(n*sizeof(BTreeNode));
for (i = 0; i < n; i++)     {
    b[i] = malloc(sizeof(BTreeNode));
    b[i]->data  = a[i];
    b[i]->left  = NULL;
    b[i]->right = NULL;
}

數組b中的指針可以理解為二叉樹的根指針。

進行n - 1次循環建立Huffman樹

選擇b中根節點權值最小的兩棵二叉樹作為左右子樹組成新的二叉樹，新二叉樹的根節點權值為兩顆二叉樹根節點權值的和。

將新二叉樹添加到b中，並從b中刪除原來的兩棵二叉樹。當b中只有一棵樹時終止循環。

int k1 = -1, k2;
for (j = 0; j < n; j++)
//讓k1初始指向森林中第一棵樹，k2指向第二棵
{
    if (b[j] != NULL && k1 == -1)
    {
        k1 = j;
        continue;
    }
    if (b[j] != NULL)
    {
        k2 = j;
         break;
    }
}
for (j = k2; j < n; j++)
//從當前森林中求出最小權值樹和次最小權值樹
{
    if (b[j] != NULL)
    {
    if (b[j]->data < b[k1]->data)
    {
        k2 = k1;
        k1 = j;
    }
    else if (b[j]->data < b[k2]->data)
        k2 = j;
    }
}
//由最小權值樹和次最小權值樹建立一棵新樹，q指向樹根結點
q = malloc(sizeof(BTreeNode));
q->data = b[k1]->data + b[k2]->data;
q->left = b[k1];
q->right = b[k2];

b[k1] = q;//將指向新樹的指針賦給b指針數組中k1位置
b[k2] = NULL;//k2位置為空

Huffman編碼與解碼

首先給出求帶權路徑的遞歸實現:

double WeightPathLength(BTreeNode* FBT, int len) { //len = 0
    if (FBT == NULL) {//空樹返回0
        return 0;
    }
    else
    {
        if (FBT->left == NULL && FBT->right == NULL)//訪問到葉子結點
            return FBT->data * len;
        else //訪問到非葉子結點，進行遞歸調用，返回左右子樹的帶權路徑長度之和，len遞增
            return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);
    }
}

上述算法實際上通過雙遞歸遍歷了Huffman樹。

改進上述算法得到求哈夫曼編碼的實現：

static int index = 0;
char *c;
void HuffManCoding(FILE *fp, BTreeNode* FBT, int len)//len初始值為0
{
    static int a[10];//定義靜態數組a，保存每個葉子的編碼，數組長度至少是樹深度減一
    if (FBT != NULL)//訪問到葉子結點時輸出其保存在數組a中的0和1序列編碼
    {
        if (FBT->left == NULL && FBT->right == NULL)
        {
            int i;
            fprintf(fp,"%c %d:",c[index++],FBT->data);
            for (i = 0; i < len; i++)
                fprintf(fp,"%d", a[i]);
           fprintf(fp,"\n");
        }
        else//訪問到非葉子結點時分別向左右子樹遞歸調用，並把分支上的0、1編碼保存到數組a
        {   //的對應元素中，向下深入一層時len值增1
            a[len] = 0;
            HuffManCoding(fp, FBT->left, len + 1);
            a[len] = 1;
            HuffManCoding(fp, FBT->right, len + 1);
        }
    }
}

節點的Huffman編碼由它在Huffman樹中的位置決定。從根節點到任意節點有且僅有一條路徑，且路徑可以唯一確定節點。因此規定從左子結點經過編碼為0，從右子結點經過編碼為1，路徑序列作為編碼。

由Huffman樹和Huffman編碼的性質可知，Huffman編碼是一種不等長編碼。在構造過程中，兩個權值較小的節點生成一棵新的二叉樹，根節點的權值為左右子節點的和，並不實際代表字符。也就是說，較短的編碼不可能是較長編碼的前綴。

Huffman樹從葉子到根構造，靠近根的字符節點權值與幾個靠近葉子的節點權值和相近，故而靠近根的字符節點權值較高即編碼較短。

解碼過程可以由字符串匹配來完成：

//Decoding
for(i = 0; code[i]; i++) {
    for (j = 0; j < n; j++) {
        t = 1;
        for (k = 0; coding[j][k]; k++) {
            if (code[i + k] != coding[j][k]) {
                t = 0;
                break;
            }
        }
        if (t == 1) {
            append(out,c[j]);
            i = i + k - 1;
            break;
        }
    }
}
printf("%s\n",out);
//Huffman.c
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct
{
    int data;
    struct BTreeNode* left;
    struct BTreeNode* right;
}BTreeNode;

#define M 32
char coding[M][M];

BTreeNode* CreateHuffman(int a[], int n)
{
    int i, j;
    BTreeNode **b, *q;
    b = malloc(n*sizeof(BTreeNode));
    for (i = 0; i < n; i++)     {
        b[i] = malloc(sizeof(BTreeNode));
        b[i]->data  = a[i];
        b[i]->left  = NULL;
        b[i]->right = NULL;
    }
    for (i = 1; i < n; i++)//進行 n-1 次循環建立哈夫曼樹
    {
        int k1 = -1, k2;
        for (j = 0; j < n; j++)        {
            if (b[j] != NULL && k1 == -1)
            {
                k1 = j;
                continue;
            }
            if (b[j] != NULL)
            {
                k2 = j;
                break;
            }
        }
        for (j = k2; j < n; j++)//從當前森林中求出最小權值樹和次最小
        {
            if (b[j] != NULL)
            {
                if (b[j]->data < b[k1]->data)
                {
                    k2 = k1;
                    k1 = j;
                }
                else if (b[j]->data < b[k2]->data)
                    k2 = j;
            }
        }
        q = malloc(sizeof(BTreeNode));
        q->data = b[k1]->data + b[k2]->data;
        q->left = b[k1];
        q->right = b[k2];

        b[k1] = q;
        b[k2] = NULL;
    }
    free(b); 
    return q; 
}

double WeightPathLength(BTreeNode* FBT, int len)//len初始為0
{
    if (FBT == NULL) {
        return 0;
    }
    else {
        if (FBT->left == NULL && FBT->right == NULL) {
            return FBT->data * len;
        }
        else {
            return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);
        }
    }
}

static int index = 0;
char *c;
void HuffManCoding(FILE *fp, BTreeNode* FBT, int len)//len初始值為0
{
    static int a[10];   
    if (FBT != NULL)    {
            if (FBT->left == NULL && FBT->right == NULL) {
                int i;
                fprintf(fp,"%c %d:",c[index++],FBT->data);
                for (i = 0; i < len; i++)
                    fprintf(fp,"%d", a[i]);
               fprintf(fp,"\n");
            }
            else {  
                a[len] = 0;
                HuffManCoding(fp, FBT->left, len + 1);
                a[len] = 1;
                HuffManCoding(fp, FBT->right, len + 1);
            }
        }
}

void append(char *str, char ch) {
    int i;
    for (i = 0; str[i];i++);
    str[i] = ch;
    str[i+1] = ‘\0‘;
}

int main()
{
    int i, j, k, n, t;
    int* arr;
    char ch, in[M] = {‘\0‘}, code[M*M] = {‘\0‘}, out[M] = {‘\0‘};
    BTreeNode* fbt;
    FILE *fp;

    //Input
    freopen("test.in","r",stdin);
    scanf("%d", &n);
    arr = (int *)malloc(n * sizeof(int));
    c   = (char *)malloc(n * sizeof(char));
    arr[0] = 186;
    c[0] = ‘ ‘;
    //原諒樓主這裏偷懶，空格字符的輸入有點麻煩所以直接寫入了
    for (i = 1; i < n; i++) {
        getchar();
        scanf("%c %d",&c[i],&arr[i]);
    }

    //huffman coding
    fbt = CreateHuffman(arr, n);
    fp = fopen("code.txt","w");
    HuffManCoding(fp, fbt, 0);
    fflush(fp);

    //Encoding
    fp = fopen("code.txt","r");
    for (i = 0; i < n; i++) {
       fgetc(fp);
       fscanf(fp,"%c %d:%s", &t, &ch, &coding[i]);
    }
    fp = fopen("src.in","r");
    fscanf(fp, "%s", in);
    for (i = 0; in[i]; i++) {
        for (j = 0; j < n; j++) {
            if (c[j] == in[i]) {
                strcat(code,coding[j]);
            }
        }
    }
    printf("%s\n",code);

    //Decoding
    for(i = 0; code[i]; i++) {
        for (j = 0; j < n; j++) {
            t = 1;
            for (k = 0; coding[j][k]; k++) {
                if (code[i + k] != coding[j][k]) {
                    t = 0;
                    break;
                }
            }
            if (t == 1) {
                append(out,c[j]);
                i = i + k - 1;
                break;
            }
        }
    }
    printf("%s\n",out);
    return 0;
}

測試數據：

test.in：

27
a 4
b 13 
c 22 
d 32 
e 103 
f 21 
g 15 
h 47 
i 57 
j 1 
k 5 
l 32 
m 20 
n 57
o 63 
p 15 
q 1 
r 48 
s 51 
t 80 
u 23 
v 8 
w 18 
x 1 
y 16 
z 1

Huffman樹與編碼

相關推薦

Huffman樹與編碼

reat 指針數組 get n-1 include 開始 靜態數組 當前 編碼 帶權路徑最小的二叉樹稱為最優二叉樹或Huffman（哈夫曼樹）。 Huffman樹的構造 將節點的權值存入數組中，由數組開始構造Huffman樹。初始化指針數組，指針指向含有權值的孤立節點。 b

Huffman樹與Huffman編碼—介紹與基本應用

今天來談談huffman樹吧。 先介紹一下樹的路徑長度（path length of a tree，PL），和樹的帶權路徑長度（Weighted Path Length of Tree，WPL）。我們定義每個節點到樹根的距離為l[i]。樹的路徑長度（PL）：所有節點到根的距

Huffman樹與檔案壓縮的原理

1、Huffman樹的簡單介紹以及帶權路徑長度的求解        Huffman樹，又稱為最優二叉樹，是加權路徑長度（weighted path length）最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點的權值乘上其到根結點的路徑長度。    

資料結構與演算法 (七) 哈夫曼樹（Huffman）與哈夫曼編碼

1.演算法思想          哈夫曼樹又稱最優二叉樹，是一種帶權路徑長度最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點的權值乘上其到根結點的路徑長度（若根結點為0層，葉結點到根結點的路徑長度為葉結點的層數）。樹的路徑長度是從樹根到每

【資料結構與演算法】Huffman樹&&Huffman編碼（附完整原始碼）

出處：http://blog.csdn.net/ns_code/article/details/19174553 Huffman Tree簡介     赫夫曼樹（Huffman Tree），又稱最優二叉樹，是一類帶權路徑長度最短的樹。假設有n個權值{w1,

#資料結構與演算法學習筆記#PTA17：哈夫曼樹與哈夫曼編碼 Huffman Tree & Huffman Code（C/C++）

2018.5.16 最近一段時間忙於實驗室各種專案和輔導員的各種雜活，間隔了半周沒有耐下心學習。導師最近接了一個要PK京東方的專案讓我來做總負責，確實是很驚喜了。責任心告訴我不能把工作做水了，但是還是嘗試把實權移交給師兄們比較好。 這道題可以說是樹這塊的壓軸題了，無論是程

huffman編碼解碼與huffman樹

定義：給定n個權值作為n個葉子結點，構造一棵二叉樹，若帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。 構建huffman樹： 1.根據給定的n個權值{w

5.2哈夫曼樹——哈夫曼樹與哈夫曼編碼

node i++ insert 編碼 urn all IV right style #include <stdio.h> #include <stdlib.h> struct TreeNode{ int Weight; Huffm

哈夫曼（Huffman)樹和哈夫曼編碼

選擇 其中 有一個 只有一個 bsp nbsp 例子 left style 一、哈夫曼（Huffman)樹和哈夫曼編碼 1.哈夫曼樹（Huffman)又稱最優二叉樹，是一類帶權路徑長度最短的樹， 常用於信息檢測。 定義： 結點間的路徑長度:樹中一個結點到另一個結點之間分

資料結構——第二章樹和森林：04哈夫曼樹與哈夫曼編碼

1.結點的路徑長度：從根結點到該結點的路徑上分支的數目。 2.樹的路徑長度：樹中每個結點的路徑長度之和。 3.樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度之和WPL(T) = ∑wklk（對所有葉子結點） 4.最優樹：在所有含n個結點，並帶相同權值的m叉樹中，必存在一棵其帶權路徑長度取最小值的樹，稱

數據結構——第二章樹和森林：04哈夫曼樹與哈夫曼編碼

一個 例如 stat state 森林 ont 技術 圖片 http 1.結點的路徑長度：從根結點到該結點的路徑上分支的數目。 2.樹的路徑長度：樹中每個結點的路徑長度之和。 3.樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度之和WPL(T) = ∑wklk（對所有葉子結

樹：哈夫曼樹的建立與編碼解碼

哈夫曼樹 哈夫曼樹即最優二叉樹，演算法如下： （1）在當前未使用結點中找出兩個權重最小的作為左右孩子，計算出新的根結點 （2）新的根結點繼續參與過程（1），直至所有結點連線為一棵樹 如下圖，symbol為具體字元，Frequency為出現頻率（權重） 特點：只有度數為

DS二叉樹--赫夫曼樹的構建與編碼

題目描述 給定n個權值，根據這些權值構造huffman樹，並進行huffman編碼 參考課本演算法，注意陣列訪問是從位置1開始 要求：赫夫曼的構建中，預設左孩子權值不大於右孩子權值 輸入 第一行輸入t，表示有t個測試例項 第二行先輸入n，表示第1個例項有n個權

哈夫曼樹的編碼與解碼

#include<stdio.h> #include<stdlib.h> #include<iostream> #include<string> using namespace std; #define MAXSIZE 30

Huffman樹、霍夫曼編碼

Huffman樹指的是帶權路徑長度WPL最小的二叉樹 Huffman編碼實現： package HuffmanTree; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; impo

【資料結構】哈夫曼樹的編碼與譯碼

#include <stdio.h> #include <malloc.h> #include <string.h> typedef struct { char info; int weight; int parent, lchild, rchild;

資料結構知識整理 - 哈夫曼樹與哈夫曼編碼

主要內容 基本概念 構造思路 儲存結構 構造演算法 哈夫曼編碼的引入 求哈夫曼編碼   基本概念 1）路徑：由一個結點到另一個結點之間的所有分支共同構成。 2）路徑長度：結點之間的分支數目。 3）樹的路徑長度：從樹的根

用Huffman樹實現檔案壓縮與解壓

用Huffman樹實現檔案的壓縮與解壓 我們先來了解一下什麼是Huffman樹？ 我們平常所使用的Zip等壓縮工具都是藉助Huffman樹實現的，Huffman是一種特殊的二叉樹，它是一種加權路徑最短的二叉樹， 因此也稱為最優二叉樹。 （下面用一

資料結構-2-哈夫曼樹與哈夫曼編碼 原理詳解

 首先，介紹下什麼是哈夫曼樹。哈夫曼樹又稱最優二叉樹， 是一種帶權路徑長度最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點 的權值乘上其到根結點的 路徑長度（若根結點為0層，葉結點到根結點的路徑長度 為葉結點的層數）。樹的帶權路徑長度記為WPL= (W1*L1+W

資料結構和演算法——Huffman樹和Huffman編碼

Huffman樹是一種特殊結構的二叉樹，由Huffman樹設計的二進位制字首編碼，也稱為Huffman編碼在通訊領域有著廣泛的應用。在word2vec模型中，在構建層次Softmax的過程中，也使用到了Huffman樹的知識。 在通訊中，需要將傳輸的文字轉換成