哈夫曼树与哈夫曼编码

落日映苍穹つ 2022-04-11 05:49 288阅读 0赞

参考  
\[url\]http://www.cnblogs.com/Jezze/archive/2011/12/23/2299884.html\[/url\]  
\[url\]http://blog.csdn.net/qyee16/article/details/6664377\[/url\]  
\[url\]https://mitpress.mit.edu/sicp/full-text/sicp/book/node41.html\#fig:huffman\[/url\]  
\[url\]http://www.cnblogs.com/mcgrady/p/3329825.html\[/url\]  
  
\[b\]1、概述\[/b\]  
huffman编码是一种可变长编码（ VLC：variable length coding)）方式，于1952年由huffman提出。依据字符在需要编码文件中出现的概率提供对字符的唯一编码，并且保证了可变编码的平均编码最短，被称为最优二叉树，有时又称为最佳编码。  
  
\[b\]2、原理\[/b\]  
在了解huffman树为最优二叉树时，先要明确下面几个概念：  
路径长度:树中一个节点到另一个节点之间分支构成这两个节点之间的路径，路径上的分支数目为其路径长度。  
树的路径长度:树根到每一个节点的路径长度之和 为 “l”。  
节点的带权路径长度:节点到树根之间的路径长度与节点上权的乘积。  
  
树的带权路径长度:所有节点的带权路径长度之和，记作  
\[b\] n \[/b\]  
\[b\]WPL = ∑wk \* lk\[/b\] 。  
\[b\] k=1\[/b\]  
  
n个节点，权值为\{ w1, w2, - - -,wn \}，把此n个节点为叶子节点，构造一个带n个节点叶子节点的二叉树，每个叶子节点的带权路径长度为wi。  
取节点a,b,c,d 其w\[\] = \{2, 5, 7, 4\}，a=7 构造如下三棵树为例：  
\[img\]http://hi.csdn.net/attachment/201109/8/10122444\_1315489632oS29.jpg\[/img\]  
  
图1：wpl = 7\*2 +5\*2 + 2\*2 + 4\*2 = 36  
图2：wpl = 7\*3 + 5\*3 + 2\*1 + 4\*2 = 46  
图3：wpl = 7\*1 + 5\*2 + 2\*3 + 4\*3 = 35  
可以证明（图3）其带权路径长度最短，就是huffman树。依次为两节点的连接线编码，左孩子为0，右孩子为1。那么图3就变成了（图33）：  
\[img\]http://hi.csdn.net/attachment/201109/8/10122444\_1315490168YoqU.jpg\[/img\]  
  
编码如下：a（0）、b（10）、c（110）、d（111）  
不知道是否有人会问为什么a、b、c、d都是树的叶子节点，而不存在某个是父节点呢？试想，如果a是c、d的父节点，假设a的编码为0，其左右孩子是b、c，那么b，c的编码分别是00，和01，那么当出现诸如010001的压缩串时，可分别解释为caac，cbc，因为在出现a时，如果后面的编码为0，则不确定是解释为aa还是b了，出现歧义就出问题，所以字符只能出现在叶子节点。  
在上面我们必须保证须编码的字符必须出现叶子节点，那我们怎么保证（图33）就是最短带权路径呢？我们下面一步步走下去构造huffman树，我们还假设a、b、c、d的带权为7、5、2，4。  
  
\[b\]3、构造huffman树过程 \[/b\]  
\[img\]http://hi.csdn.net/attachment/201109/8/10122444\_1315491844zphF.jpg\[/img\]  
构造huffman树的哈夫曼算法如下：  
（1）n节点的权值｛w1、w2、·····，wn｝构成n棵二叉树集合F=｛T1，T2，···，Tn｝，每棵二叉树Ti只有一个带权为Wi的根节点，左右孩子均空。  
（2）在F中选取两棵根节点权值最小的作为树的左右孩子构造一棵新的二叉树，且置根节点的权值为左右孩子权值之和，在F中删除这两棵树，新二叉树之于F中  
（3）重复（2），直到F中只有一棵树为止，这棵树就是huffman树。  
上面就是以abcd四个节点构造huffman树的过程。  
  
\[b\]4、huffman代码\[/b\]

// Huffman coding.cpp : 定义控制台应用程序的入口点。
    //Copyright@Qyee, 2011-7-30
    
    #include "stdafx.h"
    #include <iostream>
    #include <Windows.h>
    
    using namespace std;
    
    //huffman tree节点定义
    typedef struct
    {
       
    	int weight;					//保存权值
    	int parent, lchild, rchild;	//保存左右孩子的节点值
    }HuffmanNode, *HuffmanTree;
    
    typedef char **HuffmanCode;
    
    void HuffmanCoding(HuffmanTree &HT, int *w, int n);	//Huffman编码函数
    void select(HuffmanTree HT,int n, int &s1, int &s2);//选择书中节点值较小的两个节点
    void Error(char* message);		//显示错误信息
    
    int w[] = {2, 5, 7, 4};	//各节点权值
    
    int main(int argc, char* argv[])
    {
       
    	HuffmanTree HT;
    
    	HuffmanCoding(HT, w, 6);
    
    	getchar();	//在win7系统，防止直接跳出，接收字符才执行return语句
    	return 0;
    }
    
    void HuffmanCoding(HuffmanTree &HT, int *w, int n)
    {
       
    	if (n <= 1)
    		Error("code is small");
    	int m = 2 * n - 1; //n nodes create huffman tree need 2n-1 nodes
    	HT = (HuffmanNode*)malloc((m + 1) * sizeof(HuffmanNode));//Huffman tree的所有节点
    
    	int s1, s2; //record the two mini weights nodes
    
    	memset(HT, 0, (m + 1)* sizeof(HuffmanNode));	//对所有节点初始化为-0
    	//set the n nodes
    	for (int i = 1; i <= n; i++)
    	{
       
    		HT[i].weight = *w++;	//初始化各节点权值
    	}
    
    	//创建Huffman tree
    	for(int i = n + 1; i <= m; ++i)
    	{
       
    		//选择剩余节点中权值较小的s1和s2
    		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;
    	}
    
    	HuffmanCode HC;
    	int start, c, f;
    	HC = (HuffmanCode)malloc((n + 1) * sizeof(char*));
    	char* cd = (char*)malloc(n * sizeof(char));
    	cd[n - 1] = '\0';
    	for(int i = 1; i <= n; ++i)
    	{
       
    		start = n - 1;
    		for(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]);
    	}
    
    	for (int i = 1; i <= n; i++)
    	{
       
    		cout<<HC[i]<<endl;
    	}
    
    	free(cd);
    	free(HC);
    	free(HT);
    }
    
    void Error(char* message)
    {
       
    	fprintf(stderr, "Error: %s(5s will exit)", message);
    	cout<<"\n";
    	Sleep(5000);
    	exit(1);
    }
    
    void select(HuffmanTree HT, int n, int &s1, int &s2)
    {
       
    	s1 = 1;
    	s2 = 1;
    	int min  = 99999;
    	int i;
    	//选择未被使用的第一个节点，
    	for (i = 1; i <= n; ++i)
    	{
       
    		if (HT[i].parent == 0)
    		{
       
    			min = HT[i].weight;
    			break;
    		}
    	}
    
    	//find the mini s1
    	for (int p =  1; p <= n; ++p)
    	{
       
    		if(0 == HT[p].parent && min >= HT[p].weight)
    		{
       
    			s1 = p;
    			min = HT[p].weight;
    		}
    	}
    
    	//find the s2
    	min = 99999;
    	for (int q =  1; q <= n; ++q)
    	{
       
    		if(0 == HT[q].parent && min >= HT[q].weight )
    		{
       
    			if( q == s1)
    				continue;
    			s2 = q;
    			min = HT[q].weight;
    		}
    	}
    }

\[b\]5、代码流程\[/b\]  
\[img\]http://hi.csdn.net/attachment/201109/8/10122444\_1315496671rWzW.jpg\[/img\]  
  
  
\[color=darkblue\] 在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN)树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL= (W1\*L1+W2\*L2+W3\*L3+...+Wn\*Ln)，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,...n)。可以证明哈夫曼树的WPL是最小的。  
\[b\] 哈夫曼编码步骤：\[/b\]  
  
一、对给定的n个权值\{W1,W2,W3,...,Wi,...,Wn\}构成n棵二叉树的初始集合F= \{T1,T2,T3,...,Ti,...,Tn\}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算 法，一般还要求以Ti的权值Wi的升序排列。）  
  
二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。  
  
三、从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。  
  
四、重复二和三两步，直到集合F中只有一棵二叉树为止。  
  
简易的理解就是，假如我有A,B,C,D,E五个字符，出现的频率（即权值）分别为5,4,3,2,1,那么我们第一步先取两个最小权值作为左右子树构造一个新树，即取1，2构成新树，其结点为1+2=3，如图：  
\[/color\]  
  
\[align=center\]\[img\]http://images.cnblogs.com/cnblogs\_com/Jezze/201112/201112231832078695.png\[/img\]\[/align\]  
  
\[color=darkblue\] 虚线为新生成的结点，第二步再把新生成的权值为3的结点放到剩下的集合中，所以集合变成\{5,4,3,3\}，再根据第二步，取最小的两个权值构成新树，如图： \[/color\]  
\[align=center\]\[img\]http://images.cnblogs.com/cnblogs\_com/Jezze/201112/201112231832087092.png\[/img\]\[/align\]  
  
\[color=darkblue\] 再依次建立哈夫曼树，如下图： \[/color\]  
\[align=center\]\[img\]http://images.cnblogs.com/cnblogs\_com/Jezze/201112/201112231832084301.jpg\[/img\]\[/align\]  
  
其中各个权值替换对应的字符即为下图：  
\[align=center\]\[img\]http://images.cnblogs.com/cnblogs\_com/Jezze/201112/201112231832086286.jpg\[/img\]\[/align\]  
  
\[color=darkblue\] 所以各字符对应的编码为：A->11,B->10,C->00,D->011,E->010  
霍夫曼编码是一种无前缀编码。解码时不会混淆。其主要应用在数据压缩，加密解密等场合。\[/color\]  
  
\[color=darkblue\]\[b\]C语言代码实现：\[/b\]\[/color\]

/*-------------------------------------------------------------------------
     * Name:   哈夫曼编码源代码。
     * Date:   2011.04.16
     * Author: Jeffrey Hill+Jezze(解码部分)
     * 在 Win-TC 下测试通过
     * 实现过程：着先通过 HuffmanTree() 函数构造哈夫曼树，然后在主函数 main()中
     *           自底向上开始(也就是从数组序号为零的结点开始)向上层层判断，若在
     *           父结点左侧，则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。
     *------------------------------------------------------------------------*/
    #include <stdio.h>
    #include<stdlib.h>
    
    #define MAXBIT      100
    #define MAXVALUE  10000
    #define MAXLEAF     30
    #define MAXNODE    MAXLEAF*2 -1
    
    typedef struct 
    {
       
        int bit[MAXBIT];
        int start;
    } HCodeType;        /* 编码结构体 */
    typedef struct
    {
       
        int weight;
        int parent;
        int lchild;
        int rchild;
        int value;
    } HNodeType;        /* 结点结构体 */
    
    /* 构造一颗哈夫曼树 */
    void HuffmanTree (HNodeType HuffNode[MAXNODE],  int n)
    { 
        /* i、j： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，
            x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/
        int i, j, m1, m2, x1, x2;
        /* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */
        for (i=0; i<2*n-1; i++)
        {
       
            HuffNode[i].weight = 0;//权值 
            HuffNode[i].parent =-1;
            HuffNode[i].lchild =-1;
            HuffNode[i].rchild =-1;
            HuffNode[i].value=i; //实际值，可根据情况替换为字母  
        } /* end for */
    
        /* 输入 n 个叶子结点的权值 */
        for (i=0; i<n; i++)
        {
       
            printf ("Please input weight of leaf node %d: \n", i);
            scanf ("%d", &HuffNode[i].weight);
        } /* end for */
    
        /* 循环构造 Huffman 树 */
        for (i=0; i<n-1; i++)
        {
       
            m1=m2=MAXVALUE;     /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */
            x1=x2=0;
            /* 找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 */
            for (j=0; j<n+i; j++)
            {
       
                if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
                {
       
                    m2=m1; 
                    x2=x1; 
                    m1=HuffNode[j].weight;
                    x1=j;
                }
                else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
                {
       
                    m2=HuffNode[j].weight;
                    x2=j;
                }
            } /* end for */
                /* 设置找到的两个子结点 x1、x2 的父结点信息 */
            HuffNode[x1].parent  = n+i;
            HuffNode[x2].parent  = n+i;
            HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
            HuffNode[n+i].lchild = x1;
            HuffNode[n+i].rchild = x2;
    
            printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
            printf ("\n");
        } /* end for */
      /*  for(i=0;i<n+2;i++)
        {
       
            printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
                      }*///测试 
    } /* end HuffmanTree */
    
    //解码 
    void decodeing(char string[],HNodeType Buf[],int Num)
    {
       
      int i,tmp=0,code[1024];
      int m=2*Num-1;
      char *nump;
      char num[1024];
      for(i=0;i<strlen(string);i++)
      {
       
       if(string[i]=='0')
      num[i]=0;        
      else
      num[i]=1;                    
      } 
      i=0;
      nump=&num[0];
    
     while(nump<(&num[strlen(string)]))
     {tmp=m-1;
      while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
      {
       
    
       if(*nump==0)
       {
       
         tmp=Buf[tmp].lchild ;          
       } 
       else tmp=Buf[tmp].rchild;
       nump++;
    
      } 
    
      printf("%d",Buf[tmp].value);                                  
     }
    
    
    }
    
    
    int main(void)
    {
       
    
        HNodeType HuffNode[MAXNODE];            /* 定义一个结点结构体数组 */
        HCodeType HuffCode[MAXLEAF],  cd;       /* 定义一个编码结构体数组， 同时定义一个临时变量来存放求解编码时的信息 */
        int i, j, c, p, n;
        char pp[100];
        printf ("Please input n:\n");
        scanf ("%d", &n);
        HuffmanTree (HuffNode, n);
    
    
        for (i=0; i < n; i++)
        {
       
            cd.start = n-1;
            c = i;
            p = HuffNode[c].parent;
            while (p != -1)   /* 父结点存在 */
            {
       
                if (HuffNode[p].lchild == c)
                    cd.bit[cd.start] = 0;
                else
                    cd.bit[cd.start] = 1;
                cd.start--;        /* 求编码的低一位 */
                c=p;                    
                p=HuffNode[c].parent;    /* 设置下一循环条件 */
            } /* end while */
    
            /* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
            for (j=cd.start+1; j<n; j++)
            { HuffCode[i].bit[j] = cd.bit[j];}
            HuffCode[i].start = cd.start;
        } /* end for */
    
        /* 输出已保存好的所有存在编码的哈夫曼编码 */
        for (i=0; i<n; i++)
        {
       
            printf ("%d 's Huffman code is: ", i);
            for (j=HuffCode[i].start+1; j < n; j++)
            {
       
                printf ("%d", HuffCode[i].bit[j]);
            }
            printf(" start:%d",HuffCode[i].start);
    
            printf ("\n");
    
        }
    /*    for(i=0;i<n;i++){
       
        for(j=0;j<n;j++)
            {
       
                 printf ("%d", HuffCode[i].bit[j]);           
            }
            printf("\n");
            }*/
        printf("Decoding?Please Enter code:\n");
        scanf("%s",&pp);
    decodeing(pp,HuffNode,n);
        getch();
        return 0;
    }