哈夫曼树

哈夫曼树是由n个带权叶子节点构成的所有二叉树带权路径长度WPL最小的二叉树。
算法如下：
1. 由给定n个权值{w1,w2,…,wn}构造n棵只有一个叶子结点的二叉树，得到一个二叉森林即集合F={T1，T2，…，Tn}
2. 在F中选取根结点权值最小的两棵二叉树作为左右子树构造一棵二叉树，且置新树根结点的权值为左右子树的根结点权值之和
3. 在F中删去作为左右子树的这两课二叉树，并将新树加入F中
4. 重复2和3两步，直到F中只有一棵二叉树，此二叉树即为所要构造的哈夫曼树。
哈夫曼编码解码：
编码结构体

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)
{
int i,j,m1,m2,x1,x2;
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;
}
for(i=0;i<n;i++)
{
    printf("Please input weight of leaf node %d:\n",i);
    scanf("%d",&HuffNode[i].weight);
}
for(i=0;i<n-1;i++)
{
    m1=m2=MAXVALUE;
    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;
        }
    }
    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;
}
}

解码

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)]))
    {
        temp=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);
    }
}