哈夫曼编码算法

/*
 ============================================================================
 Name        : Exercise.c
 Author      : Haier
 Version     : 1.01
 Copyright   : Copyright (c) 2014
 Description : Huffman Coding in C, Ansi-style,Compile by Code:Block
 ============================================================================
 */

#include <stdio.h>
#define MAXLEN (10)
#define MAXNODE (20)

typedef struct huffnode     /*哈夫曼树节点结构*/
{
    int weight;
    int flag;
    int parent;
    int lchild;
    int rchild;
}huffnode;

typedef struct huffcode     /*哈夫曼编码节点结构*/
{
    int bits[MAXLEN];
    int start;
}huffcode;

int main()
{
    huffnode huff_node[MAXNODE];
    huffcode huff_code[MAXLEN],Temp;
    int NumberOfNode,i,j,Smallest=32767,SecondSmallest=32767;
    int SmallestIndex=0,SecondSmallestIndex=0;
    int Parent,CurrentNode;

    /*第一部分：构造哈夫曼树*/

    printf("Please input the number of node: ");
    scanf("%d",&NumberOfNode);

    for(i=0; i<2*NumberOfNode-1; i++)
    {
        huff_node[i].weight=0;
        huff_node[i].flag  =0;
        huff_node[i].lchild=-1;
        huff_node[i].rchild=-1;
        huff_node[i].parent=0;
    }

    for(i=0; i<NumberOfNode; i++)
    {
        printf("\nPlease input the weight of %d node: ",i+1);
        scanf("%d",&huff_node[i].weight);
    }

    for(i=0; i<NumberOfNode-1; i++)
    {
        Smallest=32767;
        SecondSmallest=32767;
        SmallestIndex=0;
        SecondSmallestIndex=0;

        for(j=0; j<NumberOfNode+i; j++)
        {
            if(huff_node[j].flag==0 && huff_node[j].weight<Smallest)
            {
                SecondSmallest=Smallest;
                SecondSmallestIndex=SmallestIndex;
                Smallest=huff_node[j].weight;
                SmallestIndex = j;

            }
            else if(huff_node[j].flag==0 && huff_node[j].weight<SecondSmallest)
            {
                SecondSmallest=huff_node[j].weight;
                SecondSmallestIndex=j;
            }
        }

        huff_node[SmallestIndex].parent      =NumberOfNode+i;
        huff_node[SecondSmallestIndex].parent=NumberOfNode+i;
        huff_node[SmallestIndex].flag             =1;
        huff_node[SecondSmallestIndex].flag  =1;
        huff_node[NumberOfNode+i].lchild     =SmallestIndex;
        huff_node[NumberOfNode+i].rchild     =SecondSmallestIndex;
        huff_node[NumberOfNode+i].weight=huff_node[SmallestIndex].weight+huff_node[SecondSmallestIndex].weight;
    }

    /*第二部分：求哈夫曼编码*/

    for(i=0; i<NumberOfNode; i++)
    {
        Temp.start=NumberOfNode;
        Parent=huff_node[i].parent;

        while(Parent)
        {
            if(huff_node[Parent].lchild==i)
            {
                Temp.bits[Temp.start]=0;
            }
            else
            {
                Temp.bits[Temp.start]=1;
            }

            Temp.start-=1;
            Parent=huff_node[Parent].parent;
        }

        for(j=(Temp.start+1); j<=NumberOfNode; j++)
        {
            huff_code[i].bits[j]=Temp.bits[j];
        }
        huff_code[i].start=Temp.start+1;
    }

    /*第三部分：输出编码*/

    for(i=0; i<NumberOfNode; i++)
    {
        for(j=huff_code[i].start; j<=NumberOfNode; j++)
        {
            printf("%d,",huff_code[i].bits[j]);
        }
        printf("\n");
    }

}