哈夫曼编码器

最新推荐文章于 2020-01-20 14:12:00 发布
最新推荐文章于 2020-01-20 14:12:00 发布
阅读量241 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k17041114/article/details/104164883
版权 
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <limits.h>
# include <fstream>
# include <iostream>
using namespace std;
# define  maxsize 100
 
//将信息转化为哈夫曼码 
//康玉健
//17041114 
typedef struct 
{
    int order;//序号 
    char letter;//字母 
    int count;//出现的次数 
    
}LET;//字母 
typedef struct
{
    int weight;
    int parent;
    int left_child;
    int right_child;
    char elem;
    
}HTNode,*HuffmanTree;//定义哈弗曼树 
typedef struct
{
    char letter;
    char *code;
}CODE;//哈夫曼表 
typedef char**HuffmanCode;
void creat_HuffmanTree(HuffmanTree &HT,int n,LET *letter);//创建哈弗曼树
void HuffmanTree_select(HuffmanTree &HT,int num_node,int &s1,int &s2);//进行选择 
LET* statis_letter(char *data);//统计字母个数 
int statis_letternum(LET* letter);//统计含有字符多少个 
//LET *outcome(LET*letters);//返回最终的数组
void Huffman_code(HuffmanTree &HT,HuffmanCode &HC,int n);//创建哈夫曼编码表
void print_HuffmanCode(HuffmanCode &HC,LET *letter,int n);//打印哈夫曼表 
char* output_HuffmanCode(HuffmanCode &HC,char *data,int n,LET*letter);//输出哈夫曼编码 
//void resolve_HuffmanCode(HuffmanTree &HT,HuffmanCode HC,char *code)//解哈夫曼编码 
int  Root_Tree(HuffmanTree &HT,int n);   //得到哈夫曼树的根 
void resolve_HuffmanCode(HuffmanTree &HT,LET*letter2,char *code,int n);
LET* enter_weight(int len,LET* letter);//输入权值 
void output_huffman_to_file(HuffmanTree &HT,int len);//将哈夫曼树输入到文件中 
void Init(int len,LET* letter);//初始化功能 
HuffmanTree En_code(int len,LET* letter);//编码到一个文件中 
void De_code(HuffmanTree &HT,LET*letter2,char *code,int n);//译码部分
void print_code(void); 
void print_Tree(HuffmanTree &HT,int len);

int main(void)
{
    int flag=0;
    int returnmenu;
    int choice;
    printf("****************************************\n");
    printf("*              哈夫曼编码器            *\n");
    printf("*                  版本1.0             *\n");
    printf("*                                      *\n");
    printf("*                                      *\n");
    printf("*                                      *\n");
    printf("*                                      *\n");
    system("pause");
    system("cls");
    HuffmanTree HT=NULL; 
    char data[maxsize];
    char code[maxsize];
    printf("请输入一个您要进行编码的字符串：(长度小于100)\n");
    gets(data);
    LET*letter=statis_letter(data);//统计字符串中各个字母出现的频率 
    int len=statis_letternum(letter);
    LET*letter2= enter_weight(len,letter);
    do{
    
    system("cls");
    printf("*         【1】初始化                  *\n");
    printf("*         【2】编码                    *\n");
    printf("*         【3】译码                    *\n");
    printf("*         【4】印代码文件              *\n");
    printf("*         【5】打印哈夫曼树            *\n");
    printf("请输入您的选择：\n");
    scanf("%d",&choice);
    
    if(choice==1)
    {
    Init(len,letter2);
    }
    else if(choice==2)
    {
    
    HT=En_code(len,letter2);
    }
    else if(choice==3)
    {
    FILE* fp=fopen("编完码的结果.txt","r");
    if(fp==NULL)
    {
        printf("文件打不开！\n");
    }
    else
    {
        fscanf(fp,"%s",&code);
        fclose(fp);
        De_code(HT,letter2,code,len);
    }
    
}
else if(choice==4)
{ 

    print_code();
}
else if(choice==5)
{
  
    print_Tree(HT,len);
}
else
{
    printf("输入错误！\n");
}
printf("是否返回主菜单：\n");
printf("【1】是，【2】否\n");
scanf("%d",&returnmenu);
}
while(returnmenu==1);

}
void creat_HuffmanTree(HuffmanTree &HT,int n,LET*letters)//创建哈夫曼树 
{

    int m;
    int i;
    int j;
    int s1,s2; 
    if(n<=1)
    return ;
    m=2*n-1;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
    HT[0].elem='#';
    HT[0].left_child=0;
    HT[0].right_child=0;
    HT[0].parent=0;
    HT[0].weight=0;
    for(i=1;i<=m;i++)
    {
        HT[i].elem='#';
        HT[i].parent=0;
        HT[i].left_child=0;
        HT[i].right_child=0;    
    }
    //依次输入%d个节点的位权值
    for(i=1;i<=n;i++)
    {
      HT[i].weight=letters[i-1].count;
      HT[i].elem=letters[i-1].letter;
    }
    //从1-i-1选择最小的两个节点并将权值返回给s1。s2
    for(i=n+1;i<=m;i++)
    {
        HuffmanTree_select(HT,i-1,s1,s2);
        HT[s1].parent=i;
        HT[s2].parent=i;
        HT[i].left_child=s1;
        HT[i].right_child=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;
    }
     
    
 } 
 void HuffmanTree_select(HuffmanTree &HT,int num_node,int &s1,int &s2)//选择最小权值的下标 
 {
     int i;
    s1 = s2 = 0; 
    int min1 = INT_MAX;//最小值，INT_MAX在<limits.h>中定义的
    int min2 = INT_MAX;//次小值
 
    for ( i = 1; i <=num_node; ++i )
    {
    if ( HT[i].parent == 0 )
    {//筛选没有父节点的最小和次小权值下标
        if ( HT[i].weight < min1 )
        {//如果比最小值小
        min2 = min1;
         s2 = s1;
        min1 = HT[i].weight;
        s1 = i;
        }
        else if ( (HT[i].weight >= min1) && (HT[i].weight < min2) )
           {//如果大于等于最小值，且小于次小值
        min2 = HT[i].weight;
         s2 = i;
        }
        else
        {//如果大于次小值，则什么都不做
        ;
        }
    }
    }


 }
 LET* statis_letter(char *data)// 统计多少字符串之中各个字母数目 
 {
     int i,j;
     int len;
     int count=0;
    
    LET* letter=(LET*)malloc(26*sizeof(LET));

    for(i=0;i<26;i++)//依次把26个字母放到字母结构体数组之中 
    {
        letter[i].order=i;
        letter[i].letter='A'+i;
        letter[i].count=0;
    }
    
    for(i=0;i<strlen(data);i++)
    {
        for(j=0;j<26;j++)
        {
            if(letter[j].letter==data[i])
            {
                letter[j].count++;
            }
        }
       
    }
    
    return letter;
     
     
  } 
  int statis_letternum(LET* letter)//统计字母的个数 
  {
      int i;
      int count=0;
      for(i=0;i<26;i++)
      {
          if(letter[i].count!=0)
          {
              count++;
          }
    
      }
      return count;
   } 
/*LET *outcome(LET*letters)//把所有返回一个有全部字母的数组 
{
    int i;
    int counts=0;
    int len=statis_letternum(letters);
    LET *outcome=(LET*)malloc(len*sizeof(LET));
    for(i=0;i<26;i++)
    {
        if (letters[i].count!=0)
        {
            outcome[counts].letter=letters[i].letter;
            outcome[counts].order=letters[i].count;
            outcome[counts].order=letters[i].order;
            counts++;
        }
    }
    printf("count=%d",counts);
    return outcome;
}*/
void Huffman_code(HuffmanTree &HT,HuffmanCode &HC, int n)//哈夫曼编码树 
{
    int i;
    int c;
    int start;
    int f;
    
    HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
    
    char *cd=(char*)malloc(n*sizeof(char));
    
    cd[n-1]='\0';
     
    for(i=1;i<=n;++i)
    {
        start=n-1;
        c=i;
        f=HT[i].parent;
        
        while(f!=0)
        {
            --start;
            if(HT[f].left_child==c)
            {
                cd[start]='0';
                    
            }
            else
            {
                cd[start]='1';
                
        }
            c=f;
            f=HT[f].parent;
            HC[i]=(char*)malloc((n-start)*sizeof(char));
            strcpy(HC[i],&cd[start]);
    
         } 
        
        
    
    }
    free(cd);
    
     
 }
 void print_HuffmanCode(HuffmanCode &HC,LET *letter,int n)
 {
     FILE* fp=fopen("编码表.txt","w");
     if(fp==NULL)
     {
         printf("文件打不开呀！兄弟！\n");
     }
     else
     {
     
     int i;
     for(i=0;i<n;i++)
     {
         if(letter[i].count!=0)
         {
         
         fprintf(fp,"字母："); 
         fprintf(fp,"%c ",letter[i].letter);
         fprintf(fp,"权值："); 
         fprintf(fp,"%d ",letter[i].count);
         fprintf(fp,"哈夫曼编码为：\n");
         fprintf(fp,"%s",HC[i+1]);
         fprintf(fp,"\n");
     }
         
         
     }
     fclose(fp);
    } 
 }
 char * output_HuffmanCode(HuffmanCode &HC,char *data,int n,LET* letter)
 {
        int i,j;
        CODE *HCode=(CODE*)malloc(n*sizeof(CODE));
        char *output_string=(char*)malloc(maxsize*sizeof(char));
        output_string[0]='\0';
        for(i=0;i<n;i++)
        {
            HCode[i].letter=letter[i].letter;
        }
       for(i=0;i<n;i++)
       {
           HCode[i].code=(char*)malloc(strlen(HC[i+1])*sizeof(char));
           strcpy(HCode[i].code,HC[i+1]);
        } 
        printf("转化为哈夫曼码为：\n");
        for(i=0;i<strlen(data);i++)
        {
            for(j=0;j<n;j++)
            {
                if(data[i]==HCode[j].letter)
                {
                    strcat(output_string,HCode[j].code);
                    printf("%s",HCode[j].code);
                }
            }
        }
        printf("\n");
        printf("传输的哈夫曼编码为：\n");
        puts(output_string);
        FILE* fp=fopen("编完码的结果.txt","w");
        if(fp==NULL)
        {
            printf("读取文件失败！\n");
        }
        else
        {
            for(i=0;i<strlen(output_string);i++)
            {
            if(i+1%50==0)
            {
                fprintf(fp,"\n");
            }
            fprintf(fp,"%c",output_string[i]);
        }
        }
        fclose(fp);
        return output_string;
    
        
  } 
  int  Root_Tree(HuffmanTree &HT,int n)  //返回哈弗曼树根节点的下标
  {
      int i;
      int m=2*n-1;
      for(i=1;i<=m;i++)
      {
          if(HT[i].parent==0)
          {
              break;
          }
      }
    return i;
      
   }
void resolve_HuffmanCode(HuffmanTree &HT,LET*letter2,char *code,int n)
{
    FILE* fp=fopen("译码的结果.txt","w");
    if(fp==NULL)
    {
        printf("文件打不开，我的朋友！\n");
    }
    else
    {
    
    int root=Root_Tree(HT,n); 
    int i=root;
    int weight; 
    do
    {
        
        if(*code=='0')//如果 
        {
            i=HT[i].left_child;
            
        }
        else if(*code=='1')
        {
           i=HT[i].right_child;
        }
        if(HT[i].left_child==0&&HT[i].right_child==0)//如果到达了叶子节点回到根节点 
        {
            weight=HT[i].weight;
            fprintf(fp,"%c",HT[i].elem);
             
            i=root;
            
        }
        code++;
}
while(*code!='\0');
fclose(fp);
}
 } 
LET* enter_weight(int len,LET* letter)
{   
    int i;
    int count=0;
    int weight;
    LET*letter2=(LET*)malloc(len*sizeof(LET)); 
    for(i=0;i<26;i++)
    {
        if(letter[i].count!=0)
        {
            printf("请输入%c的权值：\n",letter[i].letter);
            scanf("%d",&weight);
            letter2[count].count=weight;
            letter2[count].order=letter[i].order;
            letter2[count].letter=letter[i].letter;        
            count++;
    }
    }
    return letter2;
}  

void Init(int len,LET* letter)
{
    int i;
    int count=0;
    char data[maxsize];
    HuffmanCode HC=NULL;
    HuffmanTree HT=NULL;
    char code[100];
    
    creat_HuffmanTree(HT,len,letter);
    output_huffman_to_file(HT,len);

} 


void output_huffman_to_file(HuffmanTree &HT,int len)//打印哈夫曼树 
{
    char code[100];
    ofstream file;
    file.open("哈夫曼树.txt");
    for(int i=0;i<2*len;i++)
    {
        //file<<i<<" ";
        file<<HT[i].elem<<" ";
        file<<HT[i].weight<<" ";
        file<<HT[i].parent<<" ";
        file<<HT[i].left_child<<" ";
        file<<HT[i].right_child<<" ";
        file<<endl; 
    }
    file.close();
}  
HuffmanTree En_code(int len,LET* letter)//读取哈夫曼树并对其进行编码 
{
    //创建哈夫曼树 
    HuffmanTree HT_new=(HuffmanTree)malloc(2*len*sizeof(HTNode));
    //创建一个新的哈夫曼树
    //从文件中读取哈夫曼树
    char ch1,ch2;
    char elem;
    int weight;
    int parent;
    int left_child;
    int right_child;
    char code[100];
    HuffmanCode HC;
    FILE *fp=fopen("哈夫曼树.txt","r");

    for(int i=0;i<2*len;i++)
    {
        fscanf(fp,"%c",&elem);
        fscanf(fp,"%d",&weight);
        fscanf(fp,"%d",&parent);
        fscanf(fp,"%d",&left_child);
        fscanf(fp,"%d",&right_child);
        fscanf(fp,"%c%c",&ch1,&ch2);
        HT_new[i].elem=elem;
        HT_new[i].weight=weight;
        HT_new[i].parent=parent;
        HT_new[i].left_child=left_child;
        HT_new[i].right_child=right_child;
        
    } 
    //file.close();
    fclose(fp);
    for(int i=0;i<2*len;i++)
    {
        cout<<HT_new[i].elem<<" ";
        cout<<HT_new[i].weight<<" ";
        cout<<HT_new[i].parent<<" ";
        cout<<HT_new[i].left_child<<" ";
        cout<<HT_new[i].right_child<<endl; 
    }
    //打开要被编码的文件
    FILE *fp1=fopen("要被编码的数据.txt","r");
    fscanf(fp1,"%s",&code);
    fclose(fp1);
    Huffman_code(HT_new,HC,len);
    output_HuffmanCode(HC,code,len,letter);
    //打印哈夫曼树编码表
    print_HuffmanCode(HC,letter,len); 
    return  HT_new;
    
}
void De_code(HuffmanTree &HT,LET*letter2,char *code,int n)
{
    resolve_HuffmanCode(HT,letter2,code,n);
}
void print_code(void)
{
    char code[maxsize];
    FILE* fp=fopen("译码的结果.txt","r");
    if(fp==NULL)
    {
        printf("打不开文件啊，兄弟！\n");
        exit(-1);
     } 
     else
     {
         fscanf(fp,"%s",&code);
         fclose(fp);
     }
     printf("译码的结果为：\n");
     puts(code);
}
void print_Tree(HuffmanTree &HT,int len)
{
    FILE* fp=fopen("打印哈夫曼树.txt","w");
    if(fp==NULL)
    {
        printf("文件打不开！\n");
        exit(-1);
    }
    else
    {
        for(int i=0;i<2*len;i++)
        {
            fprintf(fp,"序号： ");
            fprintf(fp,"元素： ");
            fprintf(fp,"权值： ");
            fprintf(fp,"父母:  ");
            fprintf(fp,"左孩子： ");
            fprintf(fp,"右孩子:  ");
            fprintf(fp,"\n");
            fprintf(fp,"%d       ",i);
            fprintf(fp,"%c       ",HT[i].elem);
            fprintf(fp,"%d       ",HT[i].weight);
            fprintf(fp,"%d       ",HT[i].parent);
            fprintf(fp,"%d       ",HT[i].left_child);
            fprintf(fp,"%d       ",HT[i].right_child);
            fprintf(fp,"\n");
             
        }
        fclose(fp);
    }
}

 

梦小冷
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈夫曼编/译码器
YULIU_的博客
12-29 2436
这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。2.编码：利用已建立好的哈夫曼树，获得各个字符的哈夫曼编码，并对正文进行编码，然后输出编码结果，并存入文件(.souce)，统计文件中字符出现的频度，并以这些字符的频度作为权值，建立哈夫曼树。
【数据结构 】哈夫曼编译码器
最新发布
学海无涯的博客
01-15 1555
利用哈夫曼编码进行信息通信可大大提高信道利用率，缩短信息传输时间，降低传输成本。 要求：在发送端通过一个编码系统对待传数据预先编码；在接收端将传入的数据进行译码（复原）。对于双工信道(即可以双向传输信息的信道)，每端都需要个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼的编/译码系统。
哈夫曼编码器“数据结构课程设计”
专注技术
01-20 1760
哈夫曼编码器程序介绍程序整体设计思想程序详解数据结构动态存储静态存储编码译码编码核心思想核心代码译码核心思想核心代码哈夫曼树可视化核心思想核心代码完整代码头文件main函数程序程序部分截图程序演示资源文件完整程序 程序介绍 设计一个程序，实现哈夫曼树编码，译码，动态可视化，友好界面的功能 程序中用到了Easy-X图形库 本程序使用vs2015编写 程序整体设计思想 【main函数】 （1...
哈夫曼编码译码器实验报告（内附源代码）
12-27
哈夫曼编码译码器实验报告，内有源代码，vc++6.0写的
哈夫曼编码器.zip
03-08
4)编码：利用建好的哈夫曼树生成哈夫曼编码 5)输出编码 6)设字符集及频度如下表： 字符 空格 A B C D E F G H I J K L M 频度 186 64 13 22 32 103 21 15 47 57 1 5 32 20 字符 N O P Q R S T U V W X Y Z ...
哈夫曼编码器/译码器
07-13
利用二叉树知识，构建哈夫曼树，并对输入字符进行编码，译码操作。
哈夫曼编码压缩,解压,压缩比,编码表,储存到文件
怀着坚定的梦就能走向远方
03-12 6046
哈夫曼编码实现
霍夫曼编码，对输入的字符集和各个字符对应的权值求出每个字符的霍夫曼编码。
11-18
霍夫曼编码，对输入的字符集和各个字符对应的权值，例如A={a,b,c,d,e,f,g,h}，各个字符对应的权值为{5,29,7,8,14,23,3,11}，求出每个字符的霍夫曼编码。 【输入形式】 输入若干个字符（1 <= n <= 26），其权值为int型。 输入数据的第一行的整数n，表示字符数；接下来的n行是字符集，一行一个字符；最后一行是各字符的权值，以空格分隔。 【输出形式】 每个字符（节点）的霍夫曼编码。参见样例输出。 【样例输入】 4 a b c d 1 3 7 22 【样例输出】 a:000 b:001 c:01 　　d:1 【样例说明】 提示： 1、将最小两个子树合并过程中一定要从前向后去查找两个最小子树，最小子树作为新结点的左子树，次小子树作为新结点的右子树，编码过程中左子树定义为0，右子树定义为1 2、另外：一般原则要求： 　若有重复权值结点，原来森林中的结点优先选择（即深度小的结点优先，以确保最终总树深较浅并相对平衡）。新生成的权值和的结点后用。
哈夫曼编码译码器
07-24
数据结构课程设计的实验报告，仅限于参考，更希望可以提升你更大的能力！
程序设计训练一元稀疏多项式计算器+迷宫问题+哈夫曼编码+关键字查找.zip
02-17
采用C语言编程，基于Vs2010，包括一元稀疏多项式计算器、迷宫问题、哈夫曼编码和关键字查找，压缩包包含有工程文件以及实践报告。
霍夫曼编码判断
Bing's Blog
11-21 8597
霍夫曼编码判断@(算法学习)霍夫曼编码一定是前缀编码，即，没有任何一个编码是另一个编码的前缀。此外，还需要明白霍夫曼编码构建的树中只有度为0和2的结点，不存在度为1的结点。这与玩全二叉树是不一样的概念，玩全二叉树允许有度为1的结点。看一道题目：（1.6）根据使用频率为5个字符设计的霍夫曼编码不可能是：DA. 000 ,001, 010, 011, 1 B. 0000 ,0001, 001, 01
哈夫曼编码-贪心算法
weixin_43843978的博客
03-30 5920
哈夫曼编码的基本思想时以字符的使用频率作为权构建一颗哈夫曼树，然后利用哈夫曼树对字符进行编码。构造一颗哈夫曼树，是将所有的编码的字符作为叶子结点，该字符在文件中的使用频率作为叶子结点的权值，以自底向上的方式，通过n-1次的”合并“运算后构造处一颗树， 核心思想是权值越大的叶子离根越近。 哈夫曼算法的贪心策略是每次从树的集合中取出没有双亲权值最小的两棵树作为左右子树，构造一颗新树新树根节点的权值为其...
"高效通信：哈夫曼编码器课程设计报告
在本课程设计中，我们旨在设计一个哈夫曼编码器，以实现对数据的压缩和解压缩功能。通过对问题进行分析和确定解决方案，我们确定了以下解决方案： 首先，我们分析了使用哈夫曼编码进行通信的优势，包括提高信道利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值