对字符串进行哈夫曼编码和解码

通过查询文件中的字符以及各个字符的权值（出现次数），对某个字符串进行哈夫曼编码和解码，代码则会通过生成哈夫曼二叉树计算出各个字符的编码，存在一个文件中，这时输入要编码的字符串就可以得到其哈夫曼编码，还可以反向对01数据传解码。

#include
#include
#include
#include

#define MAXNUM 60
  
typedef struct
{  
    char ch;
    int weight; //权值，这个字符出现的频率
    int parent;
    int left;
    int right;
}HuffNode;
  
typedef struct
{
    char code[MAXNUM];
    int start;
}HuffCode;
  
HuffNode ht[MAXNUM*2]; //存放哈夫曼树
  
HuffCode hcd[MAXNUM];  //存放ht数组中对应的字符的编码
  
int n;                 //字符的个数
  
//初始化哈夫曼树ht
void initHt（）
{
    FILE * fp;
    char ch;
    int i=0;
    //从文件document/character.txt中读出要编码的字符和权值
    if（（fp=fopen（“document/character.txt““r“））==NULL）{
        printf（“can not open the file character.txt“）;
        exit（0）;
    }
    ht[i].left=ht[i].right=ht[i].parent=-1;
    while（（ch=fgetc（fp））!=EOF）{
        if（ch==‘\n‘）{
            i++;
            ht[i].left=ht[i].right=ht[i].parent=-1;
        }
        else if（（ch>=‘a‘ && ch<=‘z‘）||（ch>=‘A‘ && ch<=‘Z‘））
            ht[i].ch=ch;
        else if（ch>=‘0‘&&ch<=‘9‘）
            ht[i].weight=ht[i].weight*10+ch-‘0‘;
    }
    n=i+1;
    if（fclose（fp））{
        printf（“can not close the file character.txt“）;
        exit（0）;
    }
}
  
//构造哈夫曼树看成有n棵树，选择权值最小的两棵树合并
void createHuffTree（）
{
  
    int i=0k;
    int minIminJ;
    int f=0;
    minI=minJ=-1; //minI    for（k=n;k<2*n-1;k++）{
        //寻找ht中权值最小且无父结点的两个结点
        i=0;
        f=0;
        while（ht[i].ch!=‘\0‘）{
            if（ht[i].parent==-1）{
                if（f==0）{
                    minI=i;
                    f++;
                }else if（f==1）{
                    if（ht[i].weight                        minJ=minI;
                        minI=i;
                    }else
                        minJ=i;
                    f++;
                }else{
                    if（ht[i].weight                        minJ=minI;
                        minI=i;
                    }else if（ht[i].weight                        minJ=i;
                }
            }
            i++;
        }
        //合并两个结点
        ht[k].ch=‘#‘;
        ht[k].left=minI;
        ht[k].right=minJ;
        ht[k].weight=ht[minI].weight+ht[minJ].weight;
        ht[k].parent=-1;
        ht[minI].parent=ht[minJ].parent=k;
    }
}
  
//将一个字符串反转
void reverse（char *str）
{
    int ij;
    char ch;
    for（i=0j=strlen（str）-1;i        ch=str[i];
        str[i]=str[j];
        str[j]=ch;
    }
}
  
//哈夫曼编码，通过父节点从下往上找  
void createHuffCode（）
{
    int ijlength;
    FILE * fp;
    for（i=0;i        length=0;
        j=i;
        //给每个字符进行编码
        while（ht[j].parent!=-1）{
            if（ht[ht[j].parent].left==j）{
                hcd[i].code[length++]=0+‘0‘;
            }else
                hcd[i].code[length++]=1+‘0‘;
            j=ht[j].parent;
        }