文件压缩与解压：霍夫曼编码

文件压缩与解压：霍夫曼编码

 

　　由于计算机的存储空间，文件传输时间成本等条件的限制，产生了对文件进行压缩从而减少文件大小的需求，各种压缩算法及其技术应运而生。其中的霍夫曼编码作为无损压缩当中最好的方法，受到了广泛的应用。

　　霍夫曼编码(Huffman Coding)：

　　霍夫曼编码是一种无损压缩算法，于1952年由Divid A. Huffman在其博士论文《A Method for the Construction of Minimum-Redundancy Codes》提出。基本原理是利用二进制位代替原先字符进行存储，减少文件计算机存储的总位数从而减少文件的大小。下面用一个实例来说明其原理。

　　实例：

　　输入一个文本文件，根据Huffman算法原理对文件进行压缩，将压缩后的所有字符输入到另外一个文件上。

　　注意：实际要对文件进行压缩需要使用二进制的方式读取文件，构造Huaffman树，接着求出每个字符对应的Huffman编码，得到的编码是二进制是0和1,，而非字符型的0和1。为了说明Huffman编码的原理在本文中我使用的是字符型的0和1（下面会有解释说明）。

　　Huffman 编码是一种前缀编码，即频率越高的字符对应的编码长度越短。相对于等长度的编码来讲，大多数情况下总编码长度要短的多。对上文给的实例，其实现主要有以下几个步骤：

1. 遍历所有字符

　　遍历文件所有的字符，并统计文件中不相同的字符即其出现的个数。

　　代码如下：　

/**
    读取文本文件，遍历文件中所有的字符，统计每个字符出现的频率，将字符和其对应的频数存储
    在huffmantable结构体中，并且返回不同字符的个数
**/
int readfile(char *filename,huffmantable *node)
{

    char temp;
    int length,i;
    FILE *file;
    errno_t err;

    length=0;

    err=fopen_s(&file,filename,"r");

    if(err!=0)
    {
        printf("the file can not open!\n");
    }
    else
    {
        while((temp=fgetc(file))!=EOF)
        {
            if(length==0)
            {
                node[0].character=temp;
                node[0].count=1;
                length++;
                
            }
            else
            {
                for(i=0;i<length;i++)
                {
                    if(node[i].character==temp)
                    {
                        
                        node[i].count=node[i].count+1;//特别注意node.count没有初始化
                        break;                          //break:执行break后不执行其后的语句
                    }
                }
                    if(i==length)
                    {
                        node[length].character=temp;
                        node[length].count=1;
                        length++;
                    }
            }            
        }
    }

    fclose(file);
    return length;
}

 

　　2.  生产霍夫曼树

　　对于怎样产生霍夫曼树，引用算法导论的实例。如下图所示：

图片来源：《算法导论》

　　从该图中可以看到，这是一棵满二叉树，所有的字符信息都存储在叶子节点中，而且出现次数越小的字符越底层，即对应的路径就越长，这和频繁度越高编码越短的原则是一致的。这样总编码长度应该是所有树种最优的。

　　前缀编码：前缀编码是指任何一个字符的编码都不是其他字符编码的前缀。霍夫曼编码一定是前缀编码的原因：在霍夫曼树种没有一个字符所在的节点是其他字符的父节点。

　　代码如下：

//从所有未加入霍夫曼树中选择频率最小的字符
int chooseMin(huffmantable *priTree, int length)
{
    //huffmantable temp;
    int min=6555334;
    int minpoint=0;
    int i;

    for(i=0;i<length;i++)
        if(priTree[i].count!=-2  && priTree[i].count<min  )
        {
            min=priTree[i].count;
            minpoint=i;
        }    
        
        return minpoint;
        
}

/*  构建霍夫曼树  */
huffmantable *createHuffmanTree(huffmantable *node, int length)
{
    int i;
    int m;
    int Fmin,Smin;
    int count1;
    int count2;

    huffmantable *priArray;

    //霍夫曼树中节点总数
    m=2*length-1;

    //对结构体数组进行扩充
    priArray=(huffmantable *)malloc(sizeof(huffmantable)*m);

    //复制读取文件后取得信息到新数组
    for(i=0;i<length;i++)
    {
        //memcpy(&priArray[i],&node[i],sizeof(huffmantable));
        priArray[i].character=node[i].character;
        priArray[i].count=node[i].count;
        priArray[i].lchild=-1;
        priArray[i].rchild=-1;
        priArray[i].parent=-1;
        //priArray
    }

    //对非叶子节点进行初始化操作
    for(i=length;i<m;i++)
    {
        priArray[i].count=-1;
        priArray[i].lchild=-1;
        priArray[i].rchild=-1;
        priArray[i].parent=-1;
    }

    

    for(i=0;i<length-1;i++)
    {
        //选择第一小频率节点，
        Fmin=chooseMin(priArray,length+i);
        count1=priArray[Fmin].count;
        priArray[Fmin].count=-2;
        
        //选择第二小频率节点
        Smin=chooseMin(priArray,length+i);
        count2=priArray[Smin].count;
        priArray[Smin].count=-2;
        
        //分别链接到左子节点和右子节点
        priArray[length+i].lchild=Fmin;
        priArray[length+i].rchild=Smin;
        priArray[length+i].count=count1+count2;
        
        
        
        
        priArray[Fmin].parent=length+i;
        priArray[Smin].parent=length+i;
    }

    return priArray;

}

 

　　3. 进行编码

　　按照生成的霍夫曼树按照左0右1的原则，从根节点开始到每个叶子节点所走的路径形成的二进制序列即为霍夫曼编码。

/**
    对已经构建好了霍夫曼树（以二叉链表形式存储）遍历，生成霍夫曼编码
**/
huffmancode *huffmancoding(int length,huffmantable *priarray)
{
    huffmancode *coding;
    char *temp;
    int i;
    int clen;
    int m;

    coding=(huffmancode *)malloc(sizeof(huffmancode)*length);
    temp=(char *)malloc(sizeof(char)*length);

    for(i=0;i<length;i++)
    {
        coding[i].character=priarray[i].character;
    }


    for(i=0;i<2*length-1;i++)
    {
        priarray[i].count=0;
    }

    m=2*length-2;
    
    clen=0;

    /* 采用DFS算法进行遍历： 0表示未遍历状态；1表示遍历了左子节点，未遍历右子节点；2 表示遍历了双节点 */
    while(m!=-1)
    {
        if(priarray[m].count==0)
        {
            priarray[m].count=1;
            if(priarray[m].lchild!=-1)
            {    
                
                m=priarray[m].lchild;
                temp[clen++]='0';
            }
            else 
            {
                coding[m].codeString=(char *)malloc(sizeof(char)*clen);
                for(i=0;i<clen;i++)
                {
                    coding[m].codeString[i]=temp[i];    
                }
                coding[m].codeString[clen]='\0';//表面该叶子节点的字符对应的编码序列结束

            }
            
        }
        else if( priarray[m].count==1)
        {
            priarray[m].count=2;
            if(priarray[m].rchild!=-1)
            {
                
                m=priarray[m].rchild;
                temp[clen++]='1';
            }
        
        }
        else
        {
            priarray[m].count=0;
            m=priarray[m].parent;
            --clen;
        }

    }

    return coding;
}

　　

　　4. 霍夫曼编码替换字符

　　上文讲过，为了展现霍夫曼编码原理，该实例中我们用字符型的0和1替代二进制位的0和1，所以我们程序中使用的就是每个字符对应的字符型编码输入到另外一个文件中。(一个字符型的'0' 或者 '1' 有8位二进制的0或者1 组成，而文本文件中一个字符也对应8位，汉字对应2个字符即16位，如果我们用字符型的 '0' 和 '1' 表示霍夫曼编码实际上将字符长度扩充了8倍，所以实际用霍夫曼编码算法实现压缩不会像下文的程序中所示（但原理基本一样），而是使用二进制的0和1)。

　　代码如下：

/**
    使用两个文件操作符，一边读取字符，一边对照霍夫曼编码将对应的编码输入到另一个文件中    
**/

void zipfunc(huffmancode *code,int length)
{
    FILE *wcpp,*rcpp;
    errno_t err1,err2;
    char temp;
    int i;

    err1=fopen_s(&wcpp,"zip.txt","w");
    err2=fopen_s(&rcpp,"test.txt","r");

    if(err2!=0)
    {
        printf("The resourse file can not be found\n!");
    }
    else
    {
        if(err1!=0)
        {
            printf("The write file can not be found!\n");
        }
        else
        {
            while((temp=fgetc(rcpp))!=EOF)
            {
                for(i=0;i<length;i++)
                    if(code[i].character==temp)
                        break;
                fprintf(wcpp,"%s",code[i].codeString);
            }
        }

    }
    fclose(wcpp);
    fclose(rcpp);
}

 

　　霍夫曼解码

　　有压缩必然有解压操作。霍夫曼解码的原理很简单：将文件中形成霍夫曼编码序列和霍夫曼树对应，从树的根结点开始，如果为0则转导左子节点，如果为1 则转到右子节点，一直按照这样的对应关系进行操作，直到遇到霍夫曼树的叶子结点，将叶子结点中的字符输出，再定位到树的根结点开始遍历，如此反复，直到文件中霍夫曼编码序列遍历完为止。

　　代码如下：

void unzipfunc(huffmantable *codetable,int length)
{
    FILE *rcpp,*wcpp;
    errno_t err1,err2;
    int tempnode;
    char temp;
    int i;

    

    err1=fopen_s(&rcpp,"zip.txt","r");
    err2=fopen_s(&wcpp,"unzip.txt","w");


    if(err1!=0)
    {
        printf("The resource file can not be open!\n");
    }
    else
    {
        tempnode=length-1;
        while((temp=fgetc(rcpp))!=EOF)
        {
            //temp=fgetc(rcpp);
            if(temp=='0')
            {
                tempnode=codetable[tempnode].lchild;
            }
            else if(temp=='1')
            {
                tempnode=codetable[tempnode].rchild;
            }
            if(codetable[tempnode].lchild==-1 && codetable[tempnode].rchild==-1 )
            {
                fputc(codetable[tempnode].character,wcpp);
                tempnode=length-1;
            }
            

        }
    }
    fclose(wcpp);
    fclose(rcpp);

}

 

　　整个实例的实现代码如下：

　　

#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
#include <string.h>

 struct huffmantable
{
    char character;
    int count;
    int parent;
    int lchild;
    int rchild;
};

 struct huffmancode
 {
     char character;
     char *codeString;
 };

char *stringdata=NULL;
long Length;


int chooseMin(huffmantable *priTree, int length);
int readfile(char *filename,huffmantable *node);
huffmantable *createHuffmanTree(huffmantable *node, int length);
huffmancode *huffmancoding(huffmantable *priTree,int length,huffmantable *priarray);
int chooseMin(huffmantable *priTree, int length);

/**
    读取文本文件，遍历文件中所有的字符，统计每个字符出现的频率，将字符和其对应的频数存储
    在huffmantable结构体中，并且返回不同字符的个数
**/
int readfile(char *filename,huffmantable *node)
{

    char temp;
    int length,i;
    FILE *file;
    errno_t err;

    length=0;

    err=fopen_s(&file,filename,"r");

    if(err!=0)
    {
        printf("the file can not open!\n");
    }
    else
    {
        while((temp=fgetc(file))!=EOF)
        {
            if(length==0)
            {
                node[0].character=temp;
                node[0].count=1;
                length++;
                
            }
            else
            {
                for(i=0;i<length;i++)
                {
                    if(node[i].character==temp)
                    {
                        
                        node[i].count=node[i].count+1;//特别注意node.count没有初始化
                        break;                          //break:执行break后不执行其后的语句
                    }
                }
                    if(i==length)
                    {
                        node[length].character=temp;
                        node[length].count=1;
                        length++;
                    }
            }            
        }
    }

    fclose(file);
    return length;
}



//从所有未加入霍夫曼树中选择频率最小的字符
int chooseMin(huffmantable *priTree, int length)
{
    //huffmantable temp;
    int min=6555334;
    int minpoint=0;
    int i;

    for(i=0;i<length;i++)
        if(priTree[i].count!=-2  && priTree[i].count<min  )
        {
            min=priTree[i].count;
            minpoint=i;
        }    
        
        return minpoint;
        
}

/*  构建霍夫曼树  */
huffmantable *createHuffmanTree(huffmantable *node, int length)
{
    int i;
    int m;
    int Fmin,Smin;
    int count1;
    int count2;

    huffmantable *priArray;

    //霍夫曼树中节点总数
    m=2*length-1;

    //对结构体数组进行扩充
    priArray=(huffmantable *)malloc(sizeof(huffmantable)*m);

    //复制读取文件后取得信息到新数组
    for(i=0;i<length;i++)
    {
        //memcpy(&priArray[i],&node[i],sizeof(huffmantable));
        priArray[i].character=node[i].character;
        priArray[i].count=node[i].count;
        priArray[i].lchild=-1;
        priArray[i].rchild=-1;
        priArray[i].parent=-1;
        //priArray
    }

    //对非叶子节点进行初始化操作
    for(i=length;i<m;i++)
    {
        priArray[i].count=-1;
        priArray[i].lchild=-1;
        priArray[i].rchild=-1;
        priArray[i].parent=-1;
    }

    

    for(i=0;i<length-1;i++)
    {
        //选择第一小频率节点，
        Fmin=chooseMin(priArray,length+i);
        count1=priArray[Fmin].count;
        priArray[Fmin].count=-2;
        
        //选择第二小频率节点
        Smin=chooseMin(priArray,length+i);
        count2=priArray[Smin].count;
        priArray[Smin].count=-2;
        
        //分别链接到左子节点和右子节点
        priArray[length+i].lchild=Fmin;
        priArray[length+i].rchild=Smin;
        priArray[length+i].count=count1+count2;
        
        
        
        
        priArray[Fmin].parent=length+i;
        priArray[Smin].parent=length+i;
    }

    return priArray;

}

/**
    对已经构建好了霍夫曼树（以二叉链表形式存储）遍历，生成霍夫曼编码
**/
huffmancode *huffmancoding(int length,huffmantable *priarray)
{
    huffmancode *coding;
    char *temp;
    int i;
    int clen;
    int m;

    coding=(huffmancode *)malloc(sizeof(huffmancode)*length);
    temp=(char *)malloc(sizeof(char)*length);

    for(i=0;i<length;i++)
    {
        coding[i].character=priarray[i].character;
    }


    for(i=0;i<2*length-1;i++)
    {
        priarray[i].count=0;
    }

    m=2*length-2;
    
    clen=0;

    /* 采用DFS算法进行遍历： 0表示未遍历状态；1表示遍历了左子节点，未遍历右子节点；2 表示遍历了双节点 */
    while(m!=-1)
    {
        if(priarray[m].count==0)
        {
            priarray[m].count=1;
            if(priarray[m].lchild!=-1)
            {    
                
                m=priarray[m].lchild;
                temp[clen++]='0';
            }
            else 
            {
                coding[m].codeString=(char *)malloc(sizeof(char)*clen);
                for(i=0;i<clen;i++)
                {
                    coding[m].codeString[i]=temp[i];    
                }
                coding[m].codeString[clen]='\0';//表面该叶子节点的字符对应的编码序列结束

            }
            
        }
        else if( priarray[m].count==1)
        {
            priarray[m].count=2;
            if(priarray[m].rchild!=-1)
            {
                
                m=priarray[m].rchild;
                temp[clen++]='1';
            }
        
        }
        else
        {
            priarray[m].count=0;
            m=priarray[m].parent;
            --clen;
        }

    }

    return coding;
}

/**
    使用两个文件操作符，一边读取字符，一边对照霍夫曼编码将对应的编码输入到另一个文件中    
**/

void zipfunc(huffmancode *code,int length)
{
    FILE *wcpp,*rcpp;
    errno_t err1,err2;
    char temp;
    int i;

    err1=fopen_s(&wcpp,"zip.txt","w");
    err2=fopen_s(&rcpp,"test.txt","r");

    if(err2!=0)
    {
        printf("The resourse file can not be found\n!");
    }
    else
    {
        if(err1!=0)
        {
            printf("The write file can not be found!\n");
        }
        else
        {
            while((temp=fgetc(rcpp))!=EOF)
            {
                for(i=0;i<length;i++)
                    if(code[i].character==temp)
                        break;
                fprintf(wcpp,"%s",code[i].codeString);
            }
        }

    }
    fclose(wcpp);
    fclose(rcpp);
}


void unzipfunc(huffmantable *codetable,int length)
{
    FILE *rcpp,*wcpp;
    errno_t err1,err2;
    int tempnode;
    char temp;
    int i;

    

    err1=fopen_s(&rcpp,"zip.txt","r");
    err2=fopen_s(&wcpp,"unzip.txt","w");


    if(err1!=0)
    {
        printf("The resource file can not be open!\n");
    }
    else
    {
        tempnode=length-1;
        while((temp=fgetc(rcpp))!=EOF)
        {
            //temp=fgetc(rcpp);
            if(temp=='0')
            {
                tempnode=codetable[tempnode].lchild;
            }
            else if(temp=='1')
            {
                tempnode=codetable[tempnode].rchild;
            }
            if(codetable[tempnode].lchild==-1 && codetable[tempnode].rchild==-1 )
            {
                fputc(codetable[tempnode].character,wcpp);
                tempnode=length-1;
            }
            

        }
    }
    fclose(wcpp);
    fclose(rcpp);

}


int main()
{
    
    int i;
    int length;
    huffmantable *knode;

    Length=128;

    int min;

    huffmantable *table;
    huffmancode *result;

    knode=(huffmantable *)malloc(sizeof(huffmantable)*Length);

    for(i=0;i<Length;i++)
    {
        knode[i].count=0;
        knode[i].lchild=-1;
        knode[i].rchild=-1;
        knode[i].parent=-1;
    }


    length=readfile("test.txt",knode);
    
    for(i=0;i<length;i++)
        printf("%c\t%d\n",knode[i].character,knode[i].count);
    printf("\n");


    table=createHuffmanTree(knode,length);

    result=huffmancoding(length,table);

    zipfunc(result,length);
    
    unzipfunc(table,2*length-1);

    printf("character\thuffmancoding\n");
    for(i=0;i<length;i++)
        printf("%c\t%s\n",result[i].character,result[i].codeString);
    printf("\n");


    return 0;
}