Huffman编码的C语言实现

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

数据结构定义

typedef struct {
    unsigned int weight;
    unsigned int parent, lchild, rchild;
}   HTNode, *HuffmanTree;

typedef char **HuffmanCode;

统计字符个数

统计文章中各个字符的个数，即计算权值。

• （只考虑了大小写字母，逗号，句号，空格这55个字符，其它字符情况编码情况与此一致）

1、先一个个从文件a里读入字符，用countletter数组统计各字符出现的次数。因此，n = 55，m = 109。
2、数组下标1到26用来按顺序存放小写字母出现次数，27到52存放大写字母，53空格，54逗号，55句号。以便可以根据地址求得相应字符。

void count(int countletter[55])
{ 
    char ch;
    FILE *f;
    f = fopen("a.txt","r");
    //freopen("a.txt","r",stdin);      此条语句用来从文件“a.txt”中读入数据
    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);
}

编码

i 指向n + 1，在前i – 1 个结点中找权值最小的且parent域为0的两个结点，将他们双亲域赋值为i，将第i个结点孩子域分别赋值为权值最小的俩结点的地址，且其权值为这两个结点权值之和。然后i加一，在前i – 1个结点中重复上述步骤，直到i > m。

• 注：每次寻找权值最小的两个结点时，他们的parent必须为0

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; 	//由赫夫曼树定义可知，存在n个字符时，最终会有2*n-1个结点
    w ++;
    HT = (HuffmanTree) malloc ((m+2) * sizeof(HTNode)); 	//开辟m+2个空间，因为（1）0号单元空置（2）与本人写的select函数有关，需要一个单元来存放所有字符权值之和
    for (p = HT+1, i = 1; i <= n; ++ i, ++ p, ++ w)
        *p = {*w, 0, 0, 0};	//将字符出现次数作为权值赋值到55个字符的权值域，且将它们的双亲和孩子域都赋初值为0
    for (; i <= m; ++ i, ++ p)
        *p = {0, 0, 0, 0};	//剩下的结点权值、双亲、孩子域都赋初值为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;          
        /*
        s1,s2赋值为存放权值之和单元的下标，可以确保每次进入select函数时s1,s2
        指向的位置权值都不是当前最小的两个（即s1,s2的值在select函数中一定会改变，那么此时s1,s2指向的结点是否有双亲就不影响结果），
        就省去每次必须使s1,s2指向parent域为0结点的麻烦。 
        */                                        
        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;
    }
    
/*
对n 个结点建立Huffman树，因为编码长度最长为n - 1，创建一个长度为n的数组cd，
每次用来暂时存放每个字符的编码。Cd最后一个位置放“\0”，用来表示数组结束位置。
*/
    int start;
    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)
    {                                                                  
        start = n-1;
        for (int c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent)						//从叶子结点，沿着其双亲，判断孩子与双亲的关系
        {
            if (c == HT[f].lchild)	//如果是双亲左孩子，则cd[start]赋值为0	
                cd[--start] = '0';
            else					//如果是双亲右孩子，则cd[start]赋值为1
                cd[--start] = '1';   
        }
        HC[i] = (char *)malloc ((n-start)* sizeof(char));
        strcpy (HC[i], &cd[start]); //把cd数组从start到最后结束位置的字符串复制到HC第i个结点对应的位置，即为第i个结点的编码
    }
}

对前n个结点，i 先指向1，start用来表示cd数组的下标，对每个字符从叶子到根逆向求编码，即每次给start赋初值为n – 1，沿着叶子结点，取它的双亲结点地址（用c来记录当前结点，f来记录当前结点的双亲结点），判断它是它双亲的左孩子还是右孩子，如果是右孩子，则cd[start]赋值为1，若是左孩子，则赋值为0，赋值后start --，c指向其双亲，f指向双亲的双亲，即沿着双亲结点一直往上，每次判断左孩子还是右孩子，直到判断到根结点，即双亲域为0的结点。此时，i 指向的叶子结点的编码已经存到数组cd中，因此只需要把cd数组从start到最后结束位置的字符串复制到HC第i个结点对应的位置，即为第i个结点的编码。再将i加一，求下一个叶子结点的编码。

select函数

void Select (HuffmanTree HT, int k, int &s1, int &s2)
//约定s1指向权值最小的结点，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;
            }  
        }
    }
}

把编码存入文件中

再从文件a里读字符，根据每个字符把它对应的Huffman编码输入到文件b里。

void record(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);
}

译码

从文件b里读编码，用ch记录，每次从根结点开始，即地址为m的结点，读到字符1，则取右孩子，读到字符0，则取左孩子，一直到叶子结点，（即孩子域为0），根据它的地址计算它的字符并输出。继续从文件里读编码，从根结点开始，读字符判断左右孩子，到叶子结点，根据求得叶子结点的地址输出相对应字符，重复上述步骤，一直到文件结束。此时，已经根据编码输出了所有字符。

void yima(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')		//读到字符0，则取左孩子
                i = HT[i].lchild;
            else				//读到字符1，则取右孩子
                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);
}

主函数

int main()
{
    int countletter[100] = {0};
    HuffmanTree HT;
    HuffmanCode HC;
    count(countletter);
    HuffmanCoding (HT, HC, countletter, 55);
    record(HC); 
    yima (HT, 55);
    return 0;
}