【数据结构】Huffman树及Huffman编码的算法实现

通信工程的小伙伴请看文章使用说明

实验内容

1. 输入一段100—200字的英文短文，存入一文件a中。
2. 写函数统计短文出现的字母个数n及每个字母的出现次数u
3. 写函数以字母出现次数作权值，建Huffman树（n个叶子），给出每个字母的Huffman编码。
4. 用每个字母编码对原短文进行编码，码文存入文件b中。
5. 用Huffman树对文件b中码文进行译码，结果存入文件c中，比较a,c是否一致，以检验编码、译码的正确性。

数据结构定义

算法思想及算法设计

1. 创建哈夫曼树
   在 n个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；在原有的 n个权值中删除那两个最小的权值，同时将新权值加入到 n–2 个权值的行列中，以此类推；直到所以的结点构建成了一棵二叉树为止。
   

2. 建立哈夫曼编码
   首先分配n个字符编码的头指针向量以及求编码的工作空间，之后逐个字符求哈夫曼编码。从叶子向根逆向求每个字符的编码并存放在工作空间中，向左走为0，向右走为1。最后为第i个字符的头指针向量分配空间，将工作空间所存储的编码复制到其中。
   

3. 编码：打开a，b文件，如果从a文件中读取未到结尾，则判断字符的种类，并写入b文件中。最后关闭两个文件。
   

4. 译码：打开b，c文件，每次从根节点开始，读到1，则取其右孩子，读到0，则取其左孩子，一直到叶子节点。根据求得叶子结点的地址输出相对应字符，直到文件结尾。
   

实验代码

功能函数

函数HuffmanCoding()完成了建立哈夫曼树和哈夫曼编码的功能。

#include<iostream>
#include<string.h>
using namespace std;
#define MAXNUM 10000
typedef struct
{
    unsigned int weight;
    unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char**HuffmanCode;

void count(int countletter[55])
{ 
    char ch;
    FILE *f;
    f = fopen("a.txt","r");
    while ((ch = fgetc(f)) != EOF)
    {
        if (ch <= 'z' && ch >= 'a')
        {
            countletter [ch-'a'+1] ++;
        } 
        else    if (ch <= 'Z' && ch >= 'A')
        {
            countletter [ch-'A'+27] ++;
        }
        else if (ch == ',') 
            countletter [53] ++;
        else if (ch == '.')
            countletter [54] ++;
        else if (ch == ' ')
            countletter [55] ++;                                   
    } 
    fclose(f);
}

void Select (HuffmanTree HT, int k, int &s1, int &s2)
{
    for (int i = 1; i <= k; ++ i)
    {
        if (HT[i].parent == 0)
        {
            if (HT[i].weight <= HT[s1].weight)
            {
                s2 = s1;
                s1 = i;
            }
            else if (HT[i].weight <= HT[s2].weight)
            {
                s2 = i;
            }  
        }
    }
}

void HuffmanCoding (HuffmanTree &HT, HuffmanCode &HC, int *w, int n)
{
    HuffmanTree p;
    int i, m, s1, s2, sum = 1;
    if (n <= 1)
        return;
    m = 2*n - 1;
    w ++;
    HT = (HuffmanTree) malloc ((m+2) * sizeof(HTNode));
    for (p = HT+1, i = 1; i <= n; ++ i, ++ p, ++ w)
    {
        p->weight=*w;
        p->lchild=0;
        p->rchild=0;
        p->parent=0;
    }
    for (; i <= m; ++ i, ++ p)
    {
        p->weight=0;
        p->lchild=0;
        p->parent=0;
        p->rchild=0;
    }
    for (i = 1; i <= n; ++ i)                                               
        sum += HT[i].weight;
    HT[m+1].weight = sum + 1;
    for ( i = n+1; i <= m; ++ i)
    {
        s1 = s2 = m+1;          
        Select(HT, i-1, s1, s2);
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }

    char *cd;
    HC = (HuffmanCode) malloc ((n+1)*sizeof(char *));
    cd = (char *)malloc(n * sizeof(char));
    cd [n-1] = '\0';
    for (i = 1; i <= n; ++ i)
    {                                                                  
        int start = n-1;
        for (unsigned int c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent)
        {
            if(HT[f].lchild==c)
            cd[--start]='0';
            else
            cd[--start]='1';
        }
        HC[i] = (char *)malloc ((n-start)* sizeof(char));
        strcpy (HC[i], &cd[start]);
    }
    free(cd);
}

void Encode(HuffmanCode HC)
{
    FILE *f1, *f2;
    f1 = fopen("b.txt","w");
    f2 = fopen("a.txt","r");
    char ch;
    while ((ch = fgetc(f2)) != EOF)
    {
        if (ch <= 'z' && ch >= 'a')
            fprintf(f1,"%s",HC[ch-'a'+1]);
        else if (ch <= 'Z' && ch >= 'A')
            fprintf(f1,"%s",HC[ch-'A'+27]);
        else if (ch == ',')
            fprintf(f1,"%s",HC[53]);
        else if (ch == '.')
            fprintf(f1,"%s",HC[54]);
        else if (ch == ' ')
            fprintf(f1,"%s",HC[55]);                         
    } 
    fclose(f2);
    fclose(f1);
    cout<<"编码完成^_^"<<endl;
}

void Decode(HuffmanTree HT, int n)
{
    FILE *f, *p;
    f = fopen ("b.txt", "r");
    p = fopen ("c.txt", "w");
    char ch;
    int i = 2*n - 1;
    ch = fgetc(f);
    while (ch!= EOF )
    {
        i = 2*n - 1;
        while (HT[i].rchild != 0)
        {
            if (ch == '0')
                i = HT[i].lchild;
            else
                i = HT[i].rchild;
            ch = fgetc(f);
        }
        if (i >= 1 && i <= 26)
            fprintf (p, "%c", i + 96);
        else if( i >= 27 && i <= 52)
                fprintf(p, "%c", i + 38); 
        else if ( i == 53)
            fprintf(p, ",");
        else if (i == 54)
            fprintf(p, ".");
        else if (i == 55)
            fprintf(p, " ");
    }
    fclose(f);
    fclose(p);
    cout<<"译码完成^_^"<<endl;
}

主函数

int main()
{
    int character[100] = {0};
    HuffmanTree HT;
    HuffmanCode HC;
    count(character);
    HuffmanCoding (HT, HC,character,55);
    Encode(HC);
    Decode(HT, 55);
    cout<<"请在文件中查看结果...";
    return 0;
} 

实验结果

创建三个文件，名字可以自行定义，并与代码中的一致，注意文件路径。
在本文中，有a.txt，b.txt，c.txt三个文件，其中a.txt和c.txt在程序执行后应该相同。

分析与总结

Huffman树为最优二叉树，是一类带权路径长度最短的树。利用Huffman树求得的用于通信的二进制编码称为Huffman编码，创建编码的时间复杂度大致为O(nlogn)。Huffman编码可以之后的字符串的平均长度降低，从而可以达到无损压缩数据的目的。