数据结构——霍夫曼编码解码

#include <iostream>
#include <cstring>
using namespace std;

#define MAX 32767 
typedef struct
{
    int weight;
    char value;
    int parent;
    int lchild;
    int rchild;
}HTNode, *HuffmanTree;        //动态分配数组存储霍夫曼树
typedef struct
{ 
    char * HfmCode;            //动态分配数组，存储哈夫曼编码
    char value; 
}code, *HuffmanCode; 

//选择最小权重的两个树
void select(HuffmanTree &ht,int n,int *s1,int *s2)    
{
    /*ht,为树所在数组的头指针,n为允许查找的最大序号,s1,s2,返回最小的两个序号*/
    int p1=MAX; 
    int p2=MAX;         /*p1, p2用来记录最小的两个权, 要求p1<p2*/
    int pn1=0; 
    int pn2=0;        /*pn1, pn2 用来记录这两个权的序号*/
    int i;
    for(i=1;i<=n;i++)
    {
        if(ht[i].weight<p1 && ht[i].parent==0)    //ht[i].parent=0的作用是去掉已经选过的节点
        {
            pn2=pn1;
            p2=p1;
            pn1=i;
            p1=ht[i].weight;
        }
        else if(ht[i].weight<p2 && ht[i].parent==0)
        {
            pn2=i;
            p2=ht[i].weight;
        }
    }
    *s1=pn1;    //赋值返回
    *s2=pn2;    
}

//创建霍夫曼树
void Creat_HuffmanTree(HuffmanTree &ht,int *w,char *st,int n)
{
    int m=2*n-1;
    ht=(HuffmanTree)malloc( (m+1)*sizeof(HTNode) );        //0号单元不用
    HuffmanTree p;
    int i;
    w=w+1;    //因为w[]的0号单元没有用
    st=st+1;
    for(p=ht+1,i=1; i<=n; i++,p++,w++,st++ )        //1-n号放叶子结点，初始化
    {
        (*p).weight=*w;
        (*p).value=*st;
        (*p).parent=0;
        (*p).lchild=0;
        (*p).rchild=0;
    }
    for(; i<=m; i++,p++)        //非叶子结点初始化
    {
        (*p).weight=0;
        (*p).parent=0;
        (*p).lchild=0;
        (*p).rchild=0;
    }

    int s1,s2;    //在select函数中使用,用来存储最小权的结点的序号
    for(i=n+1;i<=m;++i)        //创建非叶子结点,建哈夫曼树
    {
        //在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，其序号分别赋值给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;
    }
}//哈夫曼树建立完毕

//输出所有节点权重
void outputHuffman(HuffmanTree &ht, int m) 
{ 
    for(int i=1;i<=m;i++)
        cout<<ht[i].weight<<" ";
} 

//从叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码
void Creat_HuffmanCode(HuffmanTree &ht,HuffmanCode &hc,int n)
{
    char *cd;
    int start;
    int c;    //c指向当前节点
    int p;    //p指向当前节点的双亲结点
    int i;

    hc=(HuffmanCode)malloc( (n+1)*sizeof(code) );    //分配n个编码的头指针
    cd=(char * )malloc(n * sizeof(char ));    //分配求当前编码的工作空间
    cd[n-1]='\0';    //从右向左逐位存放编码，首先存放编码结束符
    for(i=1;i<=n;i++)    //求n个叶子结点对应的哈夫曼编码
    {
        hc[i].value=ht[i].value;
        start=n-1;        //初始化编码起始指针
        for(c=i,p=ht[i].parent; p!=0; c=p,p=ht[p].parent)    //从叶子到根结点求编码
        {
            if(ht[p].lchild == c)
                cd[--start]='0';
            else
                cd[--start]='1';
        }
        hc[i].HfmCode = (char *)malloc(n*sizeof(char));    //为第i个编码分配空间
        strcpy(hc[i].HfmCode,&cd[start]);
    }
    free(cd);
}

//解码
void Decoding_HuffmanTree(HuffmanTree &ht,char code[],char result[])
{
    int i , k=0 ;
    int p=0, root;   
    for (root=1 ; ht[root].parent!=0 ; root=ht[root].parent)
        ;  //root是霍夫曼树的根 
    for (i=0 , p=root ; code[i]!='\0'; i++)   
    {   
        if (code[i] == '0')   
            p = ht[p].lchild;   
        else  
            p = ht[p].rchild;   
        if (ht[p].lchild==NULL && ht[p].rchild==NULL)   
        {   
            result[k++] = ht[p].value;   
            p = root;   
      }   
    }   
     result[k] = '\0';   
}

int main()
{
    HuffmanTree        HT;
    HuffmanCode        HC;
    int *w;        //动态数组，存放各字符的权重
    char *st;    //字符串，存放节点的值
    int i,n;    //n is the number of elements
    int m;

    cout<<"input the total number of the Huffman Tree:"<<endl; 
    cin>>n;
    w=(int *)malloc( (n+1)*sizeof(int) );        //0号单元不用
    st=(char *)malloc( (n+1)*sizeof(char) );    //0号单元不用

    FILE *fin=fopen("哈弗曼编码.txt","r");  
    for(i=1;i<=n;i++)
    {
        fscanf(fin,"%c%d",&st[i],&w[i]);
    }
    
    Creat_HuffmanTree(HT,w,st,n); /*构造H树*/
    
    m=2*n-1;
    outputHuffman(HT,m);    /*显示H树*/
    cout<<endl;

    Creat_HuffmanCode(HT,HC,n); /*根据H树,求每个字符的编码,放在HC中*/
    for(i=1;i<=n;i++)        /*输出编码*/ 
        cout<<HC[i].value<<"  "<<HC[i].HfmCode<<endl; 
    
    //解码
    char *code="01101110101010001110110110011100";
    char *result;
    result=(char *)malloc(100*sizeof(char));
    Decoding_HuffmanTree(HT,code,result);    //result[]存放解码结果
    for(i=0;result[i];i++) 
        cout<<result[i]<<"  "; 

    return 0;
}