哈夫曼编译系统

/*
 哈夫曼编码C语言实现 
*/
//    n个数字，对应n个权值
//  n作为主输入参数，确定需要编码的数量
//    输入n个权值，进行加权求解 
//    求解最小生成树 
// 
//    涉及数据成员：
//        weight  权值
//        parent  父节点
//         
#include<stdio.h>
#include<stdlib.h> 
#include<string>
#define TREELEN 100
#define MAXVALUE 99999
struct HuffmanNode{
    int weight;
    int parent;
    int lchild;
    int rchild;
    public: HuffmanNode(int w=0,int p=-1):weight(w),parent(p)
    {lchild=-1;
    rchild=-1;} 
}Nodes[TREELEN]; 
struct HuffmanResult{
    int weight;
    int *bit;
    int length; 
}* huffman;
/*
函数实现功能：完成哈夫曼树
              完成哈夫曼编码 
n 代表需要编码数据的个数
huffman表示要存储最终结果的数组，其中Weight存放其权值，maxbit 存放其结果 
            length表示编码长度 
*/ 
void HuffmanAnswer(int n)
{
    //申请n个保存编码 的空间 
    huffman=(HuffmanResult*)malloc(n*sizeof(HuffmanResult));
    int min1=0,min2=0;//每次寻找两个最小值，必须未访问，判断方式就是其父节点不为-1 
    int added=0;
    int i=0,j=0;
    int del1=0,del2=0;
    int bitlen=0;
    int* maxbit=(int*)malloc(n*sizeof(int));
    for(i=0;i<n;i++)
    {
        huffman[i].weight=Nodes[i].weight;
    }
    while(true)
    {
        min2=min1=MAXVALUE;
        del1=del2=0;
        for(i=0;i<n+added;i++)
        {
            //min1保留最小值，min2保存仅比Min1大的值 
            //del1 记录权值为min1的节点序号，del2记录权值为min2的节点序号 
            if(Nodes[i].parent==-1&&Nodes[i].weight<min2)
            {
                if(Nodes[i].weight<min1)
                {
                    min2=min1;
                    del2=del1;
                    min1=Nodes[i].weight;
                    del1=i;
                }
                else{
                    min2=Nodes[i].weight;
                    del2=i;
                }
            }
        }    
        if(min2==MAXVALUE)break;//处理完毕，跳出循环 
        Nodes[del1].parent=n+added;
        Nodes[del2].parent=n+added;
        Nodes[n+added].weight=min1+min2;
        Nodes[n+added].lchild=del1;
        Nodes[n+added].rchild=del2;
        added+=1;
    }
    int t=0;
    for(i=0;i<n;i++)
    {
        bitlen=0;
        j=i;
        while(Nodes[j].parent!=-1) 
        {
            t=j;
            j=Nodes[j].parent;
            if(Nodes[j].lchild==t)
                maxbit[bitlen]=0;
            else maxbit[bitlen]=1;
            bitlen++;
        }
        huffman[i].bit=(int*)malloc(bitlen*sizeof(int));
        for(j=0;j<bitlen;j++)
        huffman[i].bit[bitlen-j-1]=maxbit[j];
        huffman[i].length=bitlen;
    } 
    printf("哈夫曼树及哈夫曼编码成功！\n");
}
//index 索引序号 
//h    深度 
/*
函数功能 ：
        打印空格 
*/ 
void printSpace(int cnt,FILE* fout)
{
    for(int i=0;i<cnt;i++){
    printf("    ");
    fprintf(fout,"    ");
    } 
} 
/*
函数功能：
    打印哈夫曼树（凹陷法） 
*/ 
void printHuffTree(int index,int h,FILE* fout)
{
    if(Nodes[index].lchild==-1&&Nodes[index].rchild==-1)
    {
        printSpace(h,fout);
        fprintf(fout,"%d\n",index);
        printf("%d\n",index);
        return;
    }
    printSpace(h,fout);
    printf("%d\n",index);
    fprintf(fout,"%d\n",index);
    printHuffTree(Nodes[index].lchild,h+1,fout);
    printHuffTree(Nodes[index].rchild,h+1,fout);
}
/*
    译码功能：
        从文件中读取编码。
        手动输入编码，需要知道长度 
*/ 
void HuffmanDecoding(int n)
{
    int choice,i,len;
    char codestore[1000];
    char code;
    int tcode;
    char filename[60];
    char savename[60];
    
    FILE *fin;
    FILE *fp;
    printf("输入译码要保存的文件名（txt或bin文档）：") ;
    scanf("%s",savename);
    if(!(fin=fopen(savename,"w")))
    {
        printf("保存文档路径打开失败！") ;
        return;
    } 
    printf("请选择获取编码的方式：\n"); 
    printf("\t\t1--从文件中读取编码并翻译\n"); 
    printf("\t\t2--手动输入编码并翻译\n");
    scanf("%d",&choice);
    if(choice==1)
    {
        printf("输入编码源文件名(txt或bin文档): ");
        scanf("%s",filename);
        
        if( !(fp=fopen(filename,"r"))) 
        {
            printf("源码文档打开失败！") ;
            return;
        }
        tcode=2*n-2;
        while(!feof(fp))
        {
            code=fgetc(fp);
            if(code=='0')
                tcode=Nodes[tcode].lchild;
            else if(code=='1')
            tcode=Nodes[tcode].rchild;
            if(Nodes[tcode].lchild==-1&&Nodes[tcode].rchild==-1)
            {
                printf("%d ",tcode);// 
                fprintf(fin,"%4d",tcode);
                tcode=2*n-2;
            }
        }
        fclose(fp);
        printf("\n译码成功！\n") ;
    }
    else if(choice==2)
    {
        printf("输入编码:\n"); 
        scanf("%s",codestore);
        len=strlen(codestore);
        i=0;
        tcode=2*n-2;
        while(i<len)
        {
            if(codestore[i]=='0')
            tcode=Nodes[tcode].lchild;
            else if(codestore[i]=='1')tcode=Nodes[tcode].rchild;
            if(Nodes[tcode].lchild==-1&&Nodes[tcode].rchild==-1)
            {
                printf("%d ",tcode);// 
                fprintf(fin,"%4d",tcode);
                tcode=2*n-2;
            }
            i++;
        }
    }
    fclose(fin);
    printf("\n译码成功！\n") ;
}
void PrintHuffCode(int n)
{
    //输出所有权值所对应编码 
    int choice,i,j; 
    char savefile[60];
    int flag=0; 
    FILE *fin;
    printf("是否要保存到文件中?\n");
    printf("\t\t1: 是\n\t\t2: 不\n");
    scanf("%d",&choice);
    
    if(choice==1)
    {
        printf("输入编码要保存到文件名：");
        scanf("%s",savefile);
        if(!(fin=fopen(savefile,"w"))){
            printf("保存路径有误！\n");
            return;
        }
        flag=1;
    }
    printf("权值\t编码长度\t编码\n");
    if(flag==1)fprintf(fin,"权值\t编码长度\t编码\n");
    for(i=0;i<n;i++)
    {
        printf("%3d\t%d\t\t",huffman[i].weight,huffman[i].length);
    if(flag==1)    fprintf(fin,"%3d\t%d\t\t",huffman[i].weight,huffman[i].length);
        for(j=0;j<huffman[i].length;j++)
        {
        printf("%d",huffman[i].bit[j]);
    if(flag==1)    fprintf(fin,"%d",huffman[i].bit[j]);
        }
        printf("\n");
    }
    if(flag==1)
    {
        printf("保存到文件%s成功.\n",savefile);
    } 
}
void menu()
{
    printf("\t\t\t哈夫曼编译码系统\n");
    printf("\t\t1--输入权值并初始化数据\n");
    printf("\t\t2--译码\n");
    printf("\t\t3--打印哈夫曼树\n");
    printf("\t\t4--打印哈夫曼编码\n");
    printf("\t\t0--退出\n");
}
int main()
{
    
    int n;//参数n,代表输入权值数量 
    int i=0,j=0;
    FILE *fout;
    char save[60];
    menu();
    int ce=-1; 
    while(ce!=0)
    {
        printf("输入功能选项: "); 
        scanf("%d",&ce);
        switch(ce) 
        {
            case 1: {
            printf("输入数据数量：");
            scanf("%d",&n); 
            //输入编码节点数据 
            printf("输入各权值\n");
            for(;i<n;++i)
            scanf("%d",&Nodes[i].weight);
            HuffmanAnswer(n);}break;
            case 2:{
                HuffmanDecoding(n);
                break;
            }
            case 3: {
                printf("输入哈夫曼树保存路径：");
                 scanf("%s",save);
                 fout=fopen(save,"w");
                printHuffTree(2*n-2,0,fout);
                printf("哈夫曼树打印到文件%s成功！\n",save);
                break;
            }
            case 4:{
                PrintHuffCode(n);
                break;
            }
            default: break;
        }
    }
    return 0;
}
/*
输入数据数量：7
输入各权值
3 7 10 15 20 20 25
1 2  3 4   5  6  7
权值    编码长度        编码
  3     4               0110
  7     4               0111
 10     3               010
 15     3               110
 20     3               111
 20     2               00
 25     2               10
 
 
 输入数据数量：7
输入各权值
3 7 10 15 20 20 25

12
    10
        5
        8
            2
            7
                0
                1
    11
        6
        9
            3
            4

*/