赫夫曼树的创建以及编码的两种实现

最新推荐文章于 2020-05-13 16:07:37 发布

艾醒(AiXing-w)

最新推荐文章于 2020-05-13 16:07:37 发布

阅读量706

点赞数 6

分类专栏： C++数据结构与算法文章标签：数据结构 c++

本文链接：https://blog.csdn.net/DuLNode/article/details/105387204

版权

C++数据结构与算法专栏收录该内容

22 篇文章 2 订阅

订阅专栏

赫夫曼树，逆向求编码和正向求编码

赫夫曼树和一般的二叉树略有不同，在树中并没有直接存储信息，而是通过树的每个结点的位置来表示编码（用0或1表示），这里采用左0右1表示。
具体思路是将所需生成的编码个数n和其对应的n个权值（其中n个权值所在的结点对应着树的n个叶子节点，且树的所有结点为2n-1个）传递给HuffmanCoding函数，在函数中首先进行树的初始化，即：将第1到n个权值赋给树的第1到n个结点，第n+1到第2n-1个结点的权值为0，初始化后所有的每个结点的双亲parent，左孩子lchild，右孩子rchild都为0（都为0的原因是表的0位置不储存信息，所以在这里可以用0作为标记）。创建时先要利用Select函数来筛选出权最小的两个结点进行操作。完成树的创建后可通过遍历来求出具体的编码，求赫夫曼编码的过程实际上就是便利的过程，只不过这个遍历需要描绘出从头结点到每个叶子结点的路径，所求的编码就是路径的体现。

赫夫曼树的创建以及编码的两种实现

1.头文件

#include<iostream>
#include<string.h>
#include<malloc.h>

在创建编码表时需要采用strcpy函数来进行串操作，所以需要使用#include<string.h>，当然这里也可以使用数据结构中串操作中的相关操作。
这里用C语言的malloc而不用C++中的new是为了防止在创建赫夫曼树及其编码中动态申请后造成的混乱。

2.相关的类型的定义

/*赫夫曼树和赫夫曼编码的储存*/
typedef struct
{
 unsigned int weight;
 unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char * *HuffmanCode;//动态分配赫夫曼编码表

在定义时很容易发现除了储存权值和与树结点位置关系信息外并没有直接储存编码信息。

3.Select函数

void Select(HuffmanTree HT,int n,int &s1,int &s2)
{
 int j;
 s1=0,s2=0;
 for(s1=1;s1<=n;s1++)
 if(0==HT[s1].parent)
 break;
 else
 return;
 for(j=1+s1;j<=n;j++)
 if(HT[s1].weight>HT[j].weight&&0==HT[j].parent)
 s1=j;
 for(j=1;j<s1;j++)
 if(HT[s2].weight>HT[j].weight&&0==HT[j].parent)
 s2=j;
 for(j=s1+1;j<=n;j++)
 if(HT[s2].weight>HT[j].weight&&0==HT[j].parent)
 s2=j;   
}

s1和s2表示的是双亲为0的结点中权值最小的两个结点位置，但是这就面临的一个问题，两个的权值可能相等（即：同时都为最小），或者其中一个是最小的另外一个是第二小的。所以这里不能简单的求权第一小和第二小的结点位置，本文采用的是先求出一个最小权值的结点位置再求除去这个结点后所有符合要求的结点中权值最小的结点位置

4.赫夫曼树的创建以及从叶子到头结点创建赫夫曼编码

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int w[],int n)
{//w存放n个字符的权值，构造赫夫曼树HF,求n个字符的赫夫曼编码HC 
 if(n<=1)return;
 int m=2*n-1; 
 HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
 int p;
 int i;
 for(p=1,i=1;i<=n;++i,++p)//0号单元未用 
 {
  HT[p].weight=w[i-1];
  HT[p].parent=0;  
  HT[p].lchild=0;
  HT[p].rchild=0; 
 } 
 for(;i<=m;++i,++p)
 {
  HT[p].weight=0;
  HT[p].parent=0;  
  HT[p].lchild=0;
  HT[p].rchild=0;
 }
 for(i=n+1;i<=m;++i)//建立赫夫曼树 
 {
  int s1,s2;
  Select(HT,i-1,s1,s2);//在HT中选择parant=0且weight最小的两个结点，序号为s1,s2 
  cout<<"第"<<i-n<<"次操作的权重最低的两项：s1="<<s1<<","<<"s2="<<s2<<endl;
  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;
 }
/*---从叶子到根逆向求赫夫曼编码---*/ 
 HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
 char cd[n];//用来暂时存放
 cd[n-1]='\0';
 int c,f;
 int start;
 for(i=1;i<=n;++i)
 {
  start=n-1;
  for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
  {
   if(c==HT[f].lchild)cd[--start]='0';
   else cd[--start]='1';
  }
  HC[i]=(char *)malloc((n-start)*sizeof(char));
  strcpy(HC[i],&cd[start]);
 } 
}

（1）首先对树进行初始化，初始后结点所有的双亲，左右孩子都为0，前n个的权重为从主函数传来的权值，剩余结点权值为0。然后就是创建树，创建的时候所选取的两结点不是随意的，而是在满足条件的情况下权值最小的两个点。

以输入的权值为7，5，2，4为例
初始化后：

0	weight	parent	lchild	rchild
1	7	0	0	0
2	5	0	0	0
3	2	0	0	0
4	4	0	0	0
5	0	0	0	0
6	0	0	0	0
7	0	0	0	0

树创建完成后：

0	weight	parent	lchild	rchild
1	7	7	0	0
2	5	6	0	0
3	2	5	0	0
4	4	5	0	0
5	6	6	3	4
6	11	7	2	5
7	18	0	1	6

（2）在树完成创建后，接下来就是生成编码，所需要的0/1形式的编码就是在这个过程生成的，在这里规定为左孩子为0，右孩子为1，如果当前结点是双亲结点的左孩子则为0，右孩子则为1。由于生成编码的过程是逆向的，所以暂时存放编码的字符串cd是从最后位置向前储存的（也正是因为从后向前储存0/1，后面对编码HC赋值时采用的是strcpy(HC[i]，&cd[start])，而不是strcpy(HC[i]，cd)）。

5.赫夫曼树的创建以及从头结点到叶子节点创建编码

HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
 int cdlen,wt[m];//wt[]是为了暂时储存权重 
 p=m,cdlen=0;
 char *cd;
 for(i=1;i<=m;i++)
 {
  wt[i-1]=HT[i].weight;//为了保留权重 
  HT[i].weight=0;//遍历赫夫曼树时作为结点的指示状态 
 }
 while(p)
 {
  if(HT[p].weight==0)
  {
   HT[p].weight=1;
   if(HT[p].lchild!=0){p=HT[p].lchild;cd[cdlen++]='0';}
   else if(HT[p].rchild==0)
   {
    HC[p]=(char*)malloc((cdlen+1)*sizeof(char));
    cd[cdlen]='\0';
    strcpy(HC[p],cd);
   }    
  }
  else if(HT[p].weight==1)
  {
   HT[p].weight=2;
   if(HT[p].rchild!=0)
   {
    p=HT[p].rchild;cd[cdlen++]='1';
   }
  }
  else
  {
   HT[p].weight=0;p=HT[p].parent;--cdlen;
  }
 } 
 for(i=1;i<=m;i++)//恢复最初的权重 
 HT[i].weight=wt[i-1];

主要思想是先从根结点开始遍历，遍历方式与其他树的遍历相似，先遍历左孩子，在遍历的过程中给cd对应位置赋值，如果当前结点没有左孩子（即lchild==0）则cd最后位置赋值为’\0’，将cd复制到HC对应位置；当前结点退回到双亲结点，再前进到右孩子，如果没有右孩子回到当前结点的双亲结点。
如果使用从根遍历到叶子的话将HuffmanCoding函数中的编码部分用以上代码替换即可。

6.主函数

int main()
{
 HuffmanTree HT;
 HuffmanCode HC;
 int w[4]={7,5,2,4};
 HuffmanCoding(HT,HC,w,4);
 for(int i=1;i<=4;i++)
 cout<<"第"<<i<<"个赫夫曼码为："<<HC[i]<<endl;
 return 0;
}

主函数不设计输入功能，仅用一个示例表示7
7. 完整代码实现（注释掉的代码部分即为从根到叶子建立编码）

#include<iostream>
#include<string.h>
#include<malloc.h>
using namespace std;
/*赫夫曼树和赫夫曼编码的储存*/
typedef struct
{
 unsigned int weight;
 unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char * *HuffmanCode;//动态分配赫夫曼编码表 
void Select(HuffmanTree HT,int n,int &s1,int &s2)
{
 int j;
 s1=0,s2=0;
 for(s1=1;s1<=n;s1++)
 if(0==HT[s1].parent)
 break;
 else
 return;
 for(j=1+s1;j<=n;j++)
 if(HT[s1].weight>HT[j].weight&&0==HT[j].parent)
 s1=j;
 for(j=1;j<s1;j++)
 if(HT[s2].weight>HT[j].weight&&0==HT[j].parent)
 s2=j;
 for(j=s1+1;j<=n;j++)
 if(HT[s2].weight>HT[j].weight&&0==HT[j].parent)
 s2=j;   
}
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int w[],int n)
{//w存放n个字符的权值，构造赫夫曼树HF,求n个字符的赫夫曼编码HC 
 if(n<=1)return;
 int m=2*n-1; 
 HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
 int p;
 int i;
 for(p=1,i=1;i<=n;++i,++p)//0号单元未用 
 {
  HT[p].weight=w[i-1];
  HT[p].parent=0;  
  HT[p].lchild=0;
  HT[p].rchild=0; 
 } 
 for(;i<=m;++i,++p)
 {
  HT[p].weight=0;
  HT[p].parent=0;  
  HT[p].lchild=0;
  HT[p].rchild=0;
 }
 for(i=n+1;i<=m;++i)//建立赫夫曼树 
 {
  int s1,s2;
  Select(HT,i-1,s1,s2);//在HT中选择parant=0且weight最小的两个结点，序号为s1,s2 
  cout<<"第"<<i-n<<"次操作的权重最低的两项：s1="<<s1<<","<<"s2="<<s2<<endl;
  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;
 }
/*---从叶子到根逆向求赫夫曼编码---*/ 
 HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
 char cd[n];//用来暂时存放
 cd[n-1]='\0';
 int c,f;
 int start;
 for(i=1;i<=n;++i)
 {
  start=n-1;
  for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
  {
   if(c==HT[f].lchild)cd[--start]='0';
   else cd[--start]='1';
  }
  HC[i]=(char *)malloc((n-start)*sizeof(char));
  strcpy(HC[i],&cd[start]);
 } 
}
/*---无栈非递归遍历赫夫曼树，求赫夫曼编码---*/
/* HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
 int cdlen,wt[m];//wt[]是为了暂时储存权重 
 p=m,cdlen=0;
 char *cd;
 for(i=1;i<=m;i++)
 {
  wt[i-1]=HT[i].weight;//为了保留权重 
  HT[i].weight=0;//遍历赫夫曼树时作为结点的指示状态 
 }
 while(p)
 {
  if(HT[p].weight==0)
  {
   HT[p].weight=1;
   if(HT[p].lchild!=0){p=HT[p].lchild;cd[cdlen++]='0';}
   else if(HT[p].rchild==0)
   {
    HC[p]=(char*)malloc((cdlen+1)*sizeof(char));
    cd[cdlen]='\0';
    strcpy(HC[p],cd);
   }    
  }
  else if(HT[p].weight==1)
  {
   HT[p].weight=2;
   if(HT[p].rchild!=0)
   {
    p=HT[p].rchild;cd[cdlen++]='1';
   }
  }
  else
  {
   HT[p].weight=0;p=HT[p].parent;--cdlen;
  }
 } 
 for(i=1;i<=m;i++)//恢复最初的权重 
 HT[i].weight=wt[i-1];
}*/ 
int main()
{
 HuffmanTree HT;
 HuffmanCode HC;
 int w[4]={7,5,2,4};
 HuffmanCoding(HT,HC,w,4);
 for(int i=1;i<=4;i++)
 cout<<"第"<<i<<"个赫夫曼码为："<<HC[i]<<endl;
 return 0;
}