哈夫曼树|哈夫曼编码Haffman代码超详注释

以下是用C语言实现哈夫曼树及哈夫曼编码的代码，以及我在理解时的一些注释，希望能有帮助

#include<stdio.h>
#include<stdlib.h>
#define MaxValue 10000  //最大权值
#define MaxBit 4        //最大编码位数

typedef struct        //双亲孩子表示法 仿真指针
{
    int weight;       //权值
    int flag;         //标志（是否已加入哈夫曼树）
    int parent;       //双亲指针（双亲结点下标）
    int lchild;
    int rchild;
}HaffNode;            //哈夫曼树的结点结构

typedef struct
{//若某结点没有子结点则为叶结点
    int bit[MaxBit];  //数组（保存哈夫曼编码）
    int start;        //哈夫曼编码的起始下标
    int weight;       //权值
}Code;                //哈夫曼编码的结构

//建立叶结点个数为n，权值用数组weight存储的哈夫曼树hafftree
void Haffman(int weight[],int n,HaffNode hafftree[])
{
    int i,j,m1,m2,x1,x2;
    //哈夫曼树hafftree初始化，共有2*n-1个结点 n个原结点 n-1个合成的结点
    for(i=0;i<2*n-1;i++)
    {
        if(i<n)//若某结点没有子结点则为叶结点
            hafftree[i].weight=weight[i]; //给前n个原结点附权重
        else
            hafftree[i].weight=0;
        hafftree[i].parent=-1;
        hafftree[i].flag=0;
        hafftree[i].lchild=-1; //表示无孩子结点
        hafftree[i].rchild=-1;
    }
    //构造哈夫曼树hafftree的n-1个非叶结点，即非原有的结点
    for(i=0;i<n-1;i++)
    {
        //以下是合并得到一个结点的过程
        //每个结点的合并都要经过寻找未加入的最小和次小子树这一过程
        m1=m2=MaxValue;
        x1=x2=0;
        //找出未加入哈夫曼树的权值最小和次小的子树
        for(j=0;j<n+i;j++)
        {
            //若当前结点权值是已循环结点中最小
            if(hafftree[j].weight<m1 && hafftree[j].flag==0)
            {
                m2=m1;
                x2=x1;
                m1=hafftree[j].weight;   //m1存储最小子树的权值
                x1=j;                    //x1存储最小子树的下标
            }
            //若当前结点权值在m1与m2之间
            else if(hafftree[j].weight<m2 && hafftree[j].flag==0)
            {
                m2=hafftree[j].weight;    //m2存储次小子树的权值
                x2=j;                     //x2存储次小子树的下标
            }
        }
        //将找到的两子树合并
        hafftree[x1].parent=n+i;
        hafftree[x2].parent=n+i;
        hafftree[x1].flag=1;
        hafftree[x2].flag=1;
        hafftree[n+i].weight=hafftree[x1].weight+hafftree[x2].weight;
        hafftree[n+i].lchild=x1;         //最小子树作为新二叉树左子树
        hafftree[n+i].rchild=x2;         //次小子树作为新二叉树右子树
    }
}

//由哈夫曼树hafftree构造哈夫曼编码haffcode
void HaffmanCode(HaffNode hafftree[],int n,Code haffcode[])
{
    Code *cd=(Code *)malloc(sizeof(Code)); //开辟工作空间，临时存储编码
    int i,j,child,parent;    //child、parent仿真指针下标
    //循环得到每个叶结点的编码
    for(i=0;i<n;i++)
    {
        cd->start=n-1;                     //因为从叶结点往上求，所以起始下标是n-1
        cd->weight=hafftree[i].weight;
        child=i;
        parent=hafftree[child].parent;
        //从叶结点往上
        while(parent!=-1)  //即不是根结点
        {
            if(hafftree[parent].lchild==child)
                cd->bit[cd->start]=0;  //左孩子分支编码0
            else
                cd->bit[cd->start]=1;  //右孩子分支编码1
            cd->start--;
            child=parent;
            parent=hafftree[parent].parent;
        }
        for(j=cd->start+1;j<n;j++)
            haffcode[i].bit[j]=cd->bit[j]; //保存当前叶结点的编码
        haffcode[i].start=cd->start+1;     //保存叶结点编码的起始下标
        haffcode[i].weight=cd->weight;     //保存编码对应的权值
    }
}

int main()
{
    int i,j,n=4;
    int weight[n];
    printf("请依次输入a、b、c、d的使用频率：");
    for(i=0;i<n;i++)
        scanf("%d",&weight[i]);
    HaffNode *myhafftree=(HaffNode *)malloc(sizeof(HaffNode)*(2*n-1));
    Code *myhaffcode=(Code *)malloc(sizeof(Code)*n);
    Haffman(weight,n,myhafftree);
    HaffmanCode(myhafftree,n,myhaffcode);
    for(i=0;i<n;i++)
    {
        printf("Weight=%d   Code=",myhaffcode[i].weight);
        for(j=myhaffcode[i].start;j<n;j++)
            printf("%d",myhaffcode[i].bit[j]);
        printf("\n");
    }
    return 0;
}