精华内容
下载资源
问答
  • huffman编码C语言实验报告今日推荐 180份文档 2014...4页 1下载券 安卓版100 doors 2攻略1... 3页 1下载券 《逃脱本色》doors...。语文教育实习日志,40篇 21页 1下载券 教师实习日志 11页 1下载券 销售实习日记40篇...

    huffman编码C语言实验报告

    今日推荐 180份文档 2014...4页 1下载券 安卓版100 doors 2攻略1... 3页 1下载券 《逃脱本色》doors...。语文教育实习日志,40篇 21页 1下载券 教师实习日志 11页 1下载券 销售实习日记40篇(2) 37页 免费 通用实习日记 8页 1下载券 毕业实习日记范文 5页 1下载券...。机械振动学基础习题答案期末复习资料百度文库阅读文档14页-1下载券-上传时间:2011年12月17日互动式文档分享平台,在这里,您可以和千万网友分享自己手中的文档,全文阅读其他用户的文档,同时,也可以利用分享文档获取的积分下载文档。

    哈夫曼编码译码系统课程设计实验报告(含源代码C++_C语...

    C语言-哈夫曼编码实验报... 11页 2下载券 哈夫曼树编码课程设计实... 39...….16 -I- 东北电力大学计算机科学与技术 综合设计报告 摘 要 在这个信息...

    哈夫曼编码实验报告

    哈夫曼编码器实验报告 学院: 学院:计算机学院 班级: 班级:计科 0801 班 姓名...数据结构(C 语言版) ,清华大学出版社 【2】 谭浩强.C 语言程序设计教程,...

    哈夫曼编码实验报告

    传感器技术与测试系统实验讲义实验部分 编写 北京航空航天大学自动化科学与电气工程学院宇航学院第1节实验一信号的时频域分析及处理 6学时 实验目的 了解时域和频域转换的原理 掌握基本信号的时域和频域分析方法 了解信号处理的原理 掌握数字滤波器及窗函数的原理及应用 掌握信号采样的原理及过程 学习matlab软件编程及进行信号分析的方法 学习labview软件的编程思想及编程方法 学习使用labview的相关功能进行信号分析与处理的方法。24页 2下载券 材料力学实验指导书(工科... 40页 1下载券喜欢此文档的还喜欢...土木工程基础实验Ⅰ 实验指导书 中国矿业大学银川学院 土木工程实验室 杨维武 ...。经过入科后前三个月对各项实验的熟悉,大多数都已经基本掌握常用实验的操作及原理,此时结合实验中常遇到的相关问题,以问答题的形式考查对常用实验原理的掌握程度,并且成绩计入中期考核成绩,以此督促前三个月对实验及其原理的学习。

    编码理论实验报告实验一霍夫曼编码中信息熵及编码效率...

    第1章 绪论第2章 信源第3章 无损压缩编码理论基础第4章 熵编码——分组编码第5章 熵编码——算术编码第6章 通用信源编码第7章 有损压缩理论基础第8章 标量量化第9章 矢量量化第10章 预测编码第11章 变换编码第12章 子带编码第13章 小波变换编码第14章 分布信源编码。据介绍,自动化码头起源于欧洲,目前全球自动化码头的单机平均作业效率在每小时20个自然箱左右哈夫曼树编码实验报告,传统人工码头的单机平均作业效率为25-28个自然箱,全自动化码头也因为建设难度大、成本高、收益慢被称为“贵族码头”。 二、 香农第三定理(保真度准则下的信源编码定理) 信息论与编码基础 香农三大定理 简介 信 源 信 宿 限 失 真 信 源 编 码 器 限 失 真 信 源 译 码 器 无 失 真 信 源 编 码 器 无 失 真 信 源 译 码 器 信 道 编 码 信 道 译 码 a b c d 信道 e f g h 一般通信系统框图 信息论与编码基础 香农三大定理 简介 信息论与编码基础 香农三大定理 简介 总结: 香农第二定理(有噪信道编码定理) r &le。

    用哈夫曼编码C语言实现文件压缩

    用哈夫曼编码C语言实现文件压缩_计算机软件及应用_IT/计算机_资料。用哈...华北科技学院 《用哈夫曼编码实现文件压缩》实验报告 《用哈夫曼编码实现文件压缩...

    霍夫曼编码实验报告(C++)

    霍夫曼编码实验报告(C++)_计算机软件及应用_IT/计算机_资料。与之前上传的... 霍夫曼编码的C语言实现 10页 2下载券 霍夫曼编码 2页 1下载券 图像编码——...

    编码理论实验报告实验二信源编码——霍夫曼编码

    众所周知,在计算机当中,数据的存储和加工都是以字节作为基本单位的,一个西文字符要通过一个字节来表达,而一个汉字就要用两个字节,我们把这种每一个字符都通过相同的字节数来表达的编码形式称为定长编码.以西文为例,例如我们要在计算机当中存储这样的一句话:i am a teacher.就需要15个字节,也就是120个二进制位的数据来实现.与这种定长编码不同的是,哈夫曼编码是一种变长编码.它根据字符出现的概率来构造平均长度最短的编码.换句话说如果一个字符在一段文档当中出现的次数多,它的编码就相应的短,如果一个字符在一段文档当中出现的次数少,它的编码就相应的长.当编码中,各码字的长度严格按照对应符号出现的概率大小进行逆序排列时,则编码的平均长度是最小的.这就是哈夫曼编码实现数据压缩的基本原理.要想得到一段数据的哈夫曼编码,需要用到三个步骤:第一步:扫描需编码的数据,统计原数据中各字符出现的概率.第二步:利用得到的概率值创建哈夫曼树.第三步:对哈夫曼树进行编码,并把编码后得到的码字存储起来.因为定长编码已经用相同的位数这个条件保证了任一个字符的编码都不会成为其它编码的前缀,所以这种情况只会出现在变长编码当中,要想避免这种情况,我们就必须用一个条件来制约定长编码,这个条件就是要想成为压缩编码,变长编码就必须是前缀编码.什么是前缀编码呢。 信息论与编码基础 香农三大定理 简介 2、 香农第一定理(可变长无失真信源编码定理) rshlognlnrshlogn)(1)(定理4.1 设 信源, 若对 n},...,,{21nqns为q元离散无记忆信源s的n次扩展 xxxx},...,,{21s 进行编码, 码符号集 r, 则总可以找 到一种编码方法构成惟一可译码,使信源s中每个符号所需的平均 编码长度满足: 且当 n时有: )(log)(limnshrshnlrn信息论与编码基础 香农三大定理 简介 表述二: 若r>h(s)哈夫曼树编码实验报告, 就存在惟一可译变长编码。同其他码词长度可变的编码一样,如果码串中没有错误,可区别的不同码词的生成是基于不同符号出现的不同概率.20, p(d)=0.13。

    数据结构课程设计实验报告(赫夫曼编码)(1) 2

    数据结构课程设计哈夫曼编... 17页 免费 数据结构课程设计实验报告... 26页 免费 哈夫曼编码译码器实验报告... 15页 免费 哈夫曼编码C语言 3页 免费 哈...

    哈夫曼树实验报告(付原C语言程序)

    在哈夫曼编码树中,树的带权路径长度的含义是各个字符的码长与其出现次数的乘积之和,也就是电文的代码总长,所以采用哈夫曼树构造的编码是一种能使电文代码总长最短的不等长编码。有了字符集的哈夫曼编码表之后,对数据文件的编码过程是:依次读人文件中的字符c,在哈夫曼编码表h中找到此字符,若h[i].ch=c,则将字符c转换为h[i].bits中存放的编码串。,构造一棵哈夫曼编码树,规定哈夫曼编码树的左分支代表0,右分支代表1,则从根结点到每个叶子结点所经过的路径组成的0-1序列便是该叶子结点对应字符的编码,称为哈夫曼编码。

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/jisuanjixue/article-112205-1.html

    展开全文
  • . 教育资料 软件学院设计性实验报告 专业...理解哈夫曼树的特征及其应用在对哈夫曼树进行理解的基础上构造哈夫曼树并用构造的哈夫曼树进行编码和译码通过该实验使学生对数据结构的应用有更深层次的理解 实验仪器或设备
  • 数据结构课程 实验报告 实验名称 哈弗曼编码和译码 专业班级 电子信息科学与技术0904 姓 名 秦杰 学 号 1404090506 指导教师 胡志坤 2011年 11月 实验四哈夫曼编码和译码 实验目的和要求 掌握哈夫曼树的基本概念及其...
  • 哈夫曼编码实验报告

    千次阅读 2020-11-28 19:49:24
    哈夫曼编码实验报告 一、实验目的         通过哈夫曼编、译码算法的实现,巩固二叉树及哈夫曼树相关知识的理解掌握,训练学生运用所学知识,解决实际问题的能力。 二.实验...

    哈夫曼编码实验报告

    一、实验目的

            通过哈夫曼编、译码算法的实现,巩固二叉树及哈夫曼树相关知识的理解掌握,训练学生运用所学知识,解决实际问题的能力。

    二.实验内容

            已知每一个字符出现的频率,构造哈夫曼树,并设计哈夫曼编码。
    基本要求:
    (1)从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树;
    (2)打印每一个字符对应的哈夫曼编码。
    (3)对从终端读入的字符串进行编码,并显示编码结果。
    (4)对从终端读入的编码串进行译码,并显示译码结果。

    三、实验方案设计

    (对基本数据类型定义要有注释说明,解决问题的算法思想描述要完整,算法结构和程序功能模块之间的逻辑调用关系要清晰,关键算法要有相应的流程图,对算法的时间复杂度要进行分析)

    1.算法思想:
    (1)构造两个结构体分别存储结点的字符及权值、哈夫曼编码值:

    typedef struct
    {
     char ch;
     float weight;
     int lchild,rchild,parent;
    }hufmtree;  // 存储结点的字符及权值
    typedef struct
    {
     char bits[n];   //位串
     int start;      //编码在位串中的起始位置
     char ch;        //字符
    }codetype;  //存储哈夫曼编码值2)读取前n个结点的字符及权值,建立哈夫曼树:
    void huffman(hufmtree tree[])//建立哈夫曼树
    {
     int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
     float small1,small2,f;
     char c;
     for(i=0;i<m;i++)    //初始化
     {
      tree[i].parent=0;
      tree[i].lchild=-1;
      tree[i].rchild=-1;
      tree[i].weight=0.0;
     }
     printf("【依次读入前%d个结点的字符及权值(中间用空格隔开)】\n",n);
     for(i=0;i<n;i++)  //读入前n个结点的字符及权值
     {
      printf("输入第%d个字符和权值:",i+1);
      scanf("%c %f",&c,&f);
      getchar();
      tree[i].ch=c;
      tree[i].weight=f;
     }
     for(i=n;i<m;i++)      //进行n-1次合并,产生n-1个新结点
     {
      p1=0;p2=0;
      small1=maxval;small2=maxval;   //maxval是float类型的最大值
      for(j=0;j<i;j++)    //选出两个权值最小的根结点
       if(tree[j].parent==0)
        if(tree[j].weight<small1)
        {
         small2=small1;  //改变最小权、次小权及对应的位置
         small1=tree[j].weight;
         p2=p1;
         p1=j;
        }
        else
         if(tree[j].weight<small2)
         {
          small2=tree[j].weight;  //改变次小权及位置
          p2=j;
         }
      tree[p1].parent=i;
      tree[p2].parent=i;
      tree[i].lchild=p1;  //最小权根结点是新结点的左孩子
      tree[i].rchild=p2;  //次小权根结点是新结点的右孩子
      tree[i].weight=tree[p1].weight+tree[p2].weight;
     }
    }//哈夫曼树的建立
    

    (2)读取前n个结点的字符及权值,建立哈夫曼树:

    void huffman(hufmtree tree[])//建立哈夫曼树
    {
     int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
     float small1,small2,f;
     char c;
     for(i=0;i<m;i++)    //初始化
     {
      tree[i].parent=0;
      tree[i].lchild=-1;
      tree[i].rchild=-1;
      tree[i].weight=0.0;
     }
     printf("【依次读入前%d个结点的字符及权值(中间用空格隔开)】\n",n);
     for(i=0;i<n;i++)  //读入前n个结点的字符及权值
     {
      printf("输入第%d个字符和权值:",i+1);
      scanf("%c %f",&c,&f);
      getchar();
      tree[i].ch=c;
      tree[i].weight=f;
     }
     for(i=n;i<m;i++)      //进行n-1次合并,产生n-1个新结点
     {
      p1=0;p2=0;
      small1=maxval;small2=maxval;   //maxval是float类型的最大值
      for(j=0;j<i;j++)    //选出两个权值最小的根结点
       if(tree[j].parent==0)
        if(tree[j].weight<small1)
        {
         small2=small1;  //改变最小权、次小权及对应的位置
         small1=tree[j].weight;
         p2=p1;
         p1=j;
        }
        else
         if(tree[j].weight<small2)
         {
          small2=tree[j].weight;  //改变次小权及位置
          p2=j;
         }
      tree[p1].parent=i;
      tree[p2].parent=i;
      tree[i].lchild=p1;  //最小权根结点是新结点的左孩子
      tree[i].rchild=p2;  //次小权根结点是新结点的右孩子
      tree[i].weight=tree[p1].weight+tree[p2].weight;
     }
    }//哈夫曼树的建立
    

    (3)根据哈夫曼树求出哈夫曼编码:

    void huffmancode(codetype code[],hufmtree tree[])//根据哈夫曼树求出哈夫曼编码
    //codetype code[]为求出的哈夫曼编码
    //hufmtree tree[]为已知的哈夫曼树
    {
     int i,c,p;
     codetype cd;   //缓冲变量
     for(i=0;i<n;i++)
     {
      cd.start=n;
      cd.ch=tree[i].ch;
      c=i;       //从叶结点出发向上回溯
      p=tree[i].parent;   //tree[p]是tree[i]的双亲
      while(p!=0)
      {
       cd.start--;
       if(tree[p].lchild==c)
        cd.bits[cd.start]='0';   //tree[i]是左子树,生成代码'0'
       else
        cd.bits[cd.start]='1';   //tree[i]是右子树,生成代码'1'
       c=p;
       p=tree[p].parent;
      }
      code[i]=cd;    //第i+1个字符的编码存入code[i]
     }
    }//求哈夫曼编码
    

    (4)读入电文,根据哈夫曼树译码:

    void decode(hufmtree tree[])//依次读入电文,根据哈夫曼树译码
    {
     int i,j=0;
     char b[maxsize];
     char endflag='2';    //电文结束标志取2
     i=m-1;             //从根结点开始往下搜索
     printf("输入发送的编码(以'2'为结束标志):");
     gets(b);
     printf("译码后的字符为");
     while(b[j]!='2')
     {
      if(b[j]=='0')
       i=tree[i].lchild;   //走向左孩子
      else
       i=tree[i].rchild;   //走向右孩子
      if(tree[i].lchild==-1)     //tree[i]是叶结点
      {
       printf("%c",tree[i].ch);
       i=m-1;      //回到根结点
      }
      j++;
     }
     printf("\n");
     if(tree[i].lchild!=-1&&b[j]!='2')   //电文读完,但尚未到叶子结点
      printf("\nERROR\n");  //输入电文有错
    }//译码
    

    2.算法流程图:
    (1)哈夫曼树译码流程图:
    在这里插入图片描述

    (2)总流程图:
    在这里插入图片描述

    3.算法时间复杂度:
    (1)建立哈夫曼树时进行n-1次合并,产生n-1个新结点,并选出两个权值最小的根结点: O(n²);
    (2)根据哈夫曼树求出哈夫曼编码: O(n²);
    (3)读入电文,根据哈夫曼树译码: O(n).

    四、该程序的功能和运行结果
    (至少有三种不同的测试数据和相应的运行结果,充分体现该程序的鲁棒性)
    1.输入字符A,B,C,D,E,F及其相应权值16、12、9、30、6、3:

    在这里插入图片描述

    2.输入字符F,E,N,G,H,U,I及其相应权值30、12、23、22、12、7、9:
    在这里插入图片描述

    3.输入字符A,B,C,D,E,F,G,H,I,G及其相应权值19、23、25、18、12、67、23、9、32、33:

    在这里插入图片描述
    完整代码:

    #include<stdio.h>
    #define n 5  //叶子数目
    #define m (2*n-1)    //结点总数
    #define maxval 10000.0
    #define maxsize 100   //哈夫曼编码的最大位数
    typedef struct
    {
     char ch;
     float weight;
     int lchild,rchild,parent;
    }hufmtree;
    typedef struct
    {
     char bits[n];   //位串
     int start;      //编码在位串中的起始位置
     char ch;        //字符
    }codetype;
     
    void huffman(hufmtree tree[]);//建立哈夫曼树
    void huffmancode(codetype code[],hufmtree tree[]);//根据哈夫曼树求出哈夫曼编码
    void decode(hufmtree tree[]);//依次读入电文,根据哈夫曼树译码
     
    void main()
    {
     printf("                            ——哈夫曼编码——\n");
     printf("总共有%d个字符\n",n);
     hufmtree tree[m];
     codetype code[n];
     int i,j;//循环变量
     huffman(tree);//建立哈夫曼树
     huffmancode(code,tree);//根据哈夫曼树求出哈夫曼编码
     printf("【输出每个字符的哈夫曼编码】\n");
     for(i=0;i<n;i++)
     {
      printf("%c: ",code[i].ch);
      for(j=code[i].start;j<n;j++)
       printf("%c ",code[i].bits[j]);
      printf("\n");
     }
     printf("【读入电文,并进行译码】\n");
     decode(tree);//依次读入电文,根据哈夫曼树译码
    }
     
    void huffman(hufmtree tree[])//建立哈夫曼树
    {
     int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
     float small1,small2,f;
     char c;
     for(i=0;i<m;i++)    //初始化
     {
      tree[i].parent=0;
      tree[i].lchild=-1;
      tree[i].rchild=-1;
      tree[i].weight=0.0;
     }
     printf("【依次读入前%d个结点的字符及权值(中间用空格隔开)】\n",n);
     for(i=0;i<n;i++)  //读入前n个结点的字符及权值
     {
      printf("输入第%d个字符为和权值",i+1);
      scanf("%c %f",&c,&f);
      getchar();
      tree[i].ch=c;
      tree[i].weight=f;
     }
     for(i=n;i<m;i++)      //进行n-1次合并,产生n-1个新结点
     {
      p1=0;p2=0;
      small1=maxval;small2=maxval;   //maxval是float类型的最大值
      for(j=0;j<i;j++)    //选出两个权值最小的根结点
       if(tree[j].parent==0)
        if(tree[j].weight<small1)
        {
         small2=small1;  //改变最小权、次小权及对应的位置
         small1=tree[j].weight;
         p2=p1;
         p1=j;
        }
        else
         if(tree[j].weight<small2)
         {
          small2=tree[j].weight;  //改变次小权及位置
          p2=j;
         }
      tree[p1].parent=i;
      tree[p2].parent=i;
      tree[i].lchild=p1;  //最小权根结点是新结点的左孩子
      tree[i].rchild=p2;  //次小权根结点是新结点的右孩子
      tree[i].weight=tree[p1].weight+tree[p2].weight;
     }
    }//huffman
     
    void huffmancode(codetype code[],hufmtree tree[])//根据哈夫曼树求出哈夫曼编码
    //codetype code[]为求出的哈夫曼编码
    //hufmtree tree[]为已知的哈夫曼树
    {
     int i,c,p;
     codetype cd;   //缓冲变量
     for(i=0;i<n;i++)
     {
      cd.start=n;
      cd.ch=tree[i].ch;
      c=i;       //从叶结点出发向上回溯
      p=tree[i].parent;   //tree[p]是tree[i]的双亲
      while(p!=0)
      {
       cd.start--;
       if(tree[p].lchild==c)
        cd.bits[cd.start]='0';   //tree[i]是左子树,生成代码'0'
       else
        cd.bits[cd.start]='1';   //tree[i]是右子树,生成代码'1'
       c=p;
       p=tree[p].parent;
      }
      code[i]=cd;    //第i+1个字符的编码存入code[i]
     }
    }//huffmancode
     
    void decode(hufmtree tree[])//依次读入电文,根据哈夫曼树译码
    {
     int i,j=0;
     char b[maxsize];
     char endflag='2';    //电文结束标志取2
     i=m-1;             //从根结点开始往下搜索
     printf("输入发送的编码(以'2'为结束标志):");
     gets(b);
     printf("译码后的字符为");
     while(b[j]!='2')
     {
      if(b[j]=='0')
       i=tree[i].lchild;   //走向左孩子
      else
       i=tree[i].rchild;   //走向右孩子
      if(tree[i].lchild==-1)     //tree[i]是叶结点
      {
       printf("%c",tree[i].ch);
       i=m-1;      //回到根结点
      }
      j++;
     }
     printf("\n");
     if(tree[i].lchild!=-1&&b[j]!='2')   //电文读完,但尚未到叶子结点
      printf("\nERROR\n");  //输入电文有错
    }//decode
    
    展开全文
  • 压缩包中包含实验报告,运行视频,是数据结构实验课程作业,可以借鉴参考。其中功能包括输入字母及频率,然后生成相应的哈夫曼编码,然后编码txt文件中的文本,输出,并且会把输出结果存入文件。重新打开控制台,...
  • 实验报告 3哈夫曼编 / 译码器 题目哈夫曼编 /译码器 一题目要求 写一个哈夫曼码的编 /译码系统 要求能对要传输的报文进行编码和解码 构造哈夫曼树时 权值小的放左 子树权值大的放右子树编码时右子树编码为 1左子树...
  • 实验报告 3哈夫曼编 / 译码器 题目哈夫曼编 /译码器 一题目要求 写一个哈夫曼码的编 /译码系统 要求能对要传输的报文进行编码和解码 构造哈夫曼树时 权值小的放左 子树权值大的放右子树编码时右子树编码为 1左子树...
  • 1、任务描述 实现文件中数据的加解密与压缩:将硬盘上的一个文本文件进行加密,比较加密文件和原始文件的大小差别;对加密文件进行解密,比较原始文件和解码文件的内容是否一致。... //哈夫曼树 struct fact /
  • 这是本人在《数据结构》课上的 “ 哈夫曼树编码和译码” 的实验报告及程序。建议手动敲一遍加深印象。
  • 哈夫曼树实验报告 需求分析 从终端读入一串字符 利用建立好的哈夫曼树对其进行编码 储存到文件当中去 然后从文件读入 哈夫曼编码针对每个字母对其进行译码翻译为原来的信息 二概要设计 程序分为以下几个模块 1从终端...
  • 哈夫曼树实验报告 需求分析 从终端读入一串字符 利用建立好的哈夫曼树对其进行编码 储存到文件当中去 然后从文件读入哈夫曼编码针对每个字母对其进行译码翻译为原来的信息 二概要设计 程序分为以下几个模块 1从终端...
  • 2.根据哈夫曼树对字符进行哈夫曼编码,并保存这些编码。 三、实验原理、方法和手段  试构造出问题模型,并编程实现这一问题的求解。根据实验内容编程,上机调试、得出正确的运行程序;编译运行程序,观察运行情况...

     

    二、实验内容

    1.根据给出的字符以及这些字符的使用频率构建哈夫曼树。

    2.根据哈夫曼树对字符进行哈夫曼编码,并保存这些编码。

    三、实验原理、方法和手段

        试构造出问题模型,并编程实现这一问题的求解。根据实验内容编程,上机调试、得出正确的运行程序;编译运行程序,观察运行情况和输出结果。

    六、实验步骤

    1. 建立哈夫曼树的存储结构和哈夫曼编码的存储结构。

    2. 建立哈夫曼树的函数;

    3. 哈夫曼编码的函数;

    4.哈夫曼编码的解码函数

    5. 设计测试用例进行测试。

    七、实验报告

    记录数据结构与算法设计的过程及实验步骤、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。格式见实验报告模板。测试数据及测试结果请在上交的资料中写明。

    #include <stdio.h>
    #include <string.h>
    #define N 50
    #define M 2*N-1	
    const int INF=1e9+7;
    typedef struct//哈夫曼树的存储结构 
    {
    	char data[6];
    	double weight;	
    	int parent;	
    	int lchild;		
    	int rchild;		
    } HTNode;
    typedef struct//存放哈夫曼码存储结构 
    {
    	char cd[N];		
    	int start;
    } HCode;
    void CreateHT(HTNode ht[],int n0)	//建立哈夫曼树的函数 
    {	
    	int i,k,lnode,rnode;
    	double min1,min2;
    	for (i=0;i<2*n0-1;i++)		
    		ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
    	for (i=n0;i<=2*n0-2;i++)		
    	{	
    		min1=min2=INF;//min1存最小的权值,min2存次小权值		
    		lnode=rnode=-1;
    		for (k=0;k<i;k++)//寻找ht里面未使用的最小的两个数 
    			if (ht[k].parent==-1) 
    			{	
    				if(ht[k].weight<min1)
    				{	
    					min2=min1;//保证min1<=min2 
    					rnode=lnode;
    					min1=ht[k].weight;
    					lnode=k;
    				}
    				else if(ht[k].weight<min2)
    				{	
    					min2=ht[k].weight;
    					rnode=k; 
    				}
    			}
    		ht[i].weight=ht[lnode].weight+ht[rnode].weight;
    		ht[i].lchild=lnode;
    		ht[i].rchild=rnode;
    		ht[lnode].parent=i;
    		ht[rnode].parent=i;
    	}
    }
    
    void CreateHCode(HTNode ht[],HCode hcd[],int n0)	//构造哈夫曼树编码
    {	
    	int i,f,c;
    	HCode hc;
    	for (i=0;i<n0;i++)			
    	{	
    		hc.start=n0;c=i;
    		f=ht[i].parent;
    		while (f!=-1)				
    		{	
    			if (ht[f].lchild==c)
    				hc.cd[hc.start--]='0';
    			else				
    				hc.cd[hc.start--]='1';
    			c=f;
    			f=ht[f].parent;	
    		}
    		hc.start++;			
    		hcd[i]=hc;
    	}
    }
    
    void DispHCode(HTNode ht[],HCode hcd[],int n0) 
    {
    	int i,k,temp=0;
    	double sum=0;
    	int j;
    	printf("  输出");
    	for(i=0;i<8;i++)
    		printf("%s",ht[i].data);
    	printf("的哈夫曼编码:\n");
    	for (i=0;i<n0;i++)
    	{
    		printf("    %s:\t\t",ht[i].data);
    		for (k=hcd[i].start;k<=n0;k++)
    			printf("%c",hcd[i].cd[k]);
    		printf("\n"); 
    	}	
    }
    
    void Decode(HTNode ht[],char code[]) //解码 
    {
    	printf("\n\n  对“%s”解码:\n",code);
    	int p=ht[0].parent;
    	int m;//根 
    	while(p!=-1)//找到根 
    	{
    		m=p;
    		p=ht[m].parent;	
    	}
    	int t;
    	int a1=0,a2=0;
    	for(int i=0;i<strlen(code);)
    	{
    		a1=a2;
    		t=m;
    		while(ht[t].lchild!=-1&&ht[t].rchild!=-1&&i<strlen(code)) 
    		{
    			if(code[i]== '0')                
    				t=ht[t].lchild;           
    			else  if(code[i]== '1')             
    				t=ht[t].rchild;
    			i++;			    
    		}
    		a2=i;
    		if(t==-1||ht[t].lchild!=-1&&ht[t].rchild!=-1)
    		{
    			int j=i-1;
    			printf("   ");
    			for(int j=a1;j<a2;j++)
    				printf("%c",code[j]);
    			printf(":\t错误\n");
    		} 	
    		else
    		{
    			printf("   ");
    			for(int j=a1;j<a2;j++)
    				printf("%c",code[j]);
    			printf(":%6s\n",ht[t].data);
    		}			
    	} 
    	printf("\n");
    }
    int main()
    {
    	int n=8,i;		//n表示初始字符串的个数
    	char str[][2]={"a","b","c","d","e","f","g","h"};
    	double fnum[]={0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.1};
    	char code[40];
    	HTNode ht[M];//存哈夫曼树 
    	HCode hcd[N];//存哈夫曼编码 
    	for (i=0;i<n;i++) 
    	{
    		strcpy(ht[i].data,str[i]);
    		ht[i].weight=fnum[i];
    	}
    	CreateHT(ht,n);
    	CreateHCode(ht,hcd,n);
    	DispHCode(ht,hcd,n);
    	printf("\n");
    	printf("  请输入编码:"); 
    	scanf("%s",code);
    	Decode(ht,code);
    	return 1;
    }
     
    

     

    展开全文
  • 哈夫曼树及其编码 数据结构课程设计 (源代码附实验报告) 已调试成功
  • 2008 级数据结构实验报告 实验名称 实验三实现哈夫曼树 学生姓名 * 班 级 * 班内序号 * 学 号 * 日 期 2009 年 11 月 14 日 1实验要求 利用二叉树结构实现赫夫曼编 / 解码器 基本要求 1 初始化 (Init) 能够对输入的...
  • 将任意指定的文本文件中的字符统计后,按Huffman编码方式对文件进行编码,并保存码表及建立的Huffman;用给定的码表对用Huffman方式编码的文件进行压缩和解压缩。 总体设计 详细设计 测试结果
  • 课程名称 数据结构 实验项目名称 哈夫曼码编译码器 实验目的和要求 熟练哈夫曼树的定义掌握构造哈夫曼树的方法哈夫曼编码和译码的方法 基本要求 一个完整的系统应具有以下功能 初始化从终端读入字符集大小n以及n个...
  • 北京邮电大学信息与通信工程学院 第 PAGE 1页 北京邮电大学电信工程学院 第 PAGE 1页 2008级数据结构实验报告 实验名称 实验三实现哈夫曼树 学生姓名 * 班 级 * 班内序号 * 学 号 * 日 期 200 1实验要求 利用二叉树...
  • 实用文档 标准 数据结构实验报告 实验题目 Huffman编码与解码 姓名 学号 院系 实验名称 Huffman编码与解码实验 问题描述 本实验需要以菜单形式完成以下功能 1.输入电文串 2.统计电文串中各个字符及其出现的次数 3....
  • 数据结构实验报告 实验题目 Huffman编码与解码 姓名 学号 院系 实验名称 Huffman编码与解码实验 问题描述 本实验需要以菜单形式完成以下功能 1.输入电文串 2.统计电文串中各个字符及其出现的次数 3.构造哈弗曼 4....
  • 数据结构实验报告 实验名称 实验三树 学生姓名 班 级 班内序号 学 号 日 期 1 实验目的 通过选择下面两个题目之一进行实现掌握如下内容 掌握二叉树基本操作的实现方法 了解哈夫曼树的思想和相关概念 学习使用二叉树...
  • 哈夫曼编码的两种实现(实验报告

    千次阅读 多人点赞 2018-09-20 21:23:20
    ① 问题描述:给定n个字符的权值数组w,根据哈夫曼编码与译码规则,实现一个哈夫曼编/译码系统(利用实验指导书上的27个字符的数据进行实验)。 ② 利用顺序表存储Huffman编码结果的存储方式采用书上的结构。 ...

    数据结构的某项实验

    ① 问题描述:给定n个字符的权值数组w,根据哈夫曼编码与译码规则,实现一个哈夫曼编/译码系统(利用实验指导书上的27个字符的数据进行实验)。
    ② 利用顺序表存储Huffman树,编码结果的存储方式采用书上的结构。
    ③ Huffman树的构造约定如下:
    根的权值较小的子树作为左子树,当权值相等时,则先生成的子树是左子树;
    按照结点的生成次序选择权值较小的两棵子树构造Huffman树;
    从叶子结点到根结点逆向求出每个字符的Huffman编码,不采用递归方法;
    从根结点开始实现译码,要求被译码的字符数大于20个字符。
    ④ 采用文件方式存储n个权值和待翻译的二进制代码,其余数据均不采用文件存储。

    序号 字符 权值 双亲结点 左孩子 右孩子
    1 □ 186 0 0 0
    2 A 64 0 0 0
    3 B 13 0 0 0
    4 C 22 0 0 0
    5 D 32 0 0 0
    6 E 103 0 0 0
    7 F 21 0 0 0
    8 G 15 0 0 0
    9 H 47 0 0 0
    10 I 57 0 0 0
    11 J 1 0 0 0
    12 K 5 0 0 0
    13 L 32 0 0 0
    14 M 20 0 0 0
    15 N 57 0 0 0
    16 O 63 0 0 0
    17 P 15 0 0 0
    18 Q 1 0 0 0
    19 R 48 0 0 0
    20 S 51 0 0 0
    21 T 80 0 0 0
    22 U 23 0 0 0
    23 V 8 0 0 0
    24 W 18 0 0 0
    25 X 1 0 0 0
    26 Y 16 0 0 0
    27 Z 1 0 0 0

    1. 实验过程与结果
      完整代码:(实验环境codeblock)
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //左0右1
    typedef struct
       {
          unsigned int weight;
          unsigned int parent,lchild,rchild;
          char c;
          int length;
      }HTNode, *HuffmanTree;
    typedef char **HuffmanCode;
    
    void save(int n,int w[],char code[],char ch[])
    {
    	FILE *fp;
    	char filename[20];
    	int i;
    	printf("请输入要保存的文件名称:\n");
    	scanf("%s",filename);
    	if((fp=fopen(filename,"wb"))= =NULL)//打开输出文件
    	{
    		printf("cannot open file:\n");
    		return;
    	}
    	for(i=0;i<=n;i++)
    	{
    		if(fwrite(&w[i],sizeof(int),1,fp)!=1)//数组向磁盘文件写入各叶子节点权值
    			printf("file write error!\n");
    	}
    	for(i=0;i<=n;i++)
        {
            if(fwrite(&ch[i],sizeof(char),1,fp)!=1)//数组向磁盘文件写入各叶子字母代表
    			printf("file write error!\n");
        }
    	for(i=0;i<=strlen(code);i++)
        {
          if(fwrite(&code[i],sizeof(char),1,fp)!=1)//数组向磁盘文件写入待破解电码代码
    			printf("file write error!\n");
        }
    	    printf("保存文件成功!!!");
    	fclose(fp);
    }
    void read(int n,int w[],char code[],char ch[])
    {
        FILE *fp;
        char filename[20];
        int i;
        printf("请输入读入的文件名:\n");
        scanf("%s",filename);
    	if((fp=fopen(filename,"rb"))= =NULL)//以只读方式打开二进制文件
    	{   printf("can not open file\n");
    		fclose(fp);
    	}
    	for(i=0;i<=n;i++)
        fread(&w[i],sizeof(int),1,fp);//磁盘文件向数组读入
        for(i=0;i<=n;i++)
        fread(&ch[i],sizeof(char),1,fp);
        for(i=0;i<=strlen(code);i++)
        fread(&code[i],sizeof(char),1,fp);
        printf("读入数据成功!!!!");
        fclose(fp);
    }
      void createHuffmanTree(HuffmanTree \*HT, int w[], int n,char ch[])
      {
         int m = 2 * n - 1;
         int s1,s2,i;
         \*HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));
         for(i = 1; i <= n; i++)
         { (\*HT)[i].weight = w[i]; (\*HT)[i].lchild = 0;
              (\*HT)[i].parent = 0;(\*HT)[i].rchild = 0;
               (\*HT)[i].c=ch[i]; (\*HT)[i].length=0;
          }
         for(i = n + 1; i <= m; i++)
          {(\*HT)[i].weight = 0;(\*HT)[i].lchild = 0;
             (\*HT)[i].parent = 0;(\*HT)[i].rchild = 0;
              (\*HT)[i].c='\0'; (\*HT)[i].length=0;
         }
         printf("\n构建哈夫曼树: \n");
         for(i = n + 1; i <= m; i++)
         { select(HT, i-1, &s1, &s2); (\*HT)[s1].parent = i;
             (\*HT)[s2].parent = i;(\*HT)[i].lchild = s1;
             (\*HT)[i].rchild = s2;
          (\*HT)[i].weight = (\*HT)[s1].weight + (\*HT)[s2].weight;
         } printf("\n");
     }
     void select(HuffmanTree \*HT, int n, int \*s1, int \*s2)
      { int i = 0,min;
          for(i = 1; i <= n; i++)
          {if((\*HT)[i].parent == 0)
              {min = i; break;
              }
          }
          for(i = 1; i <= n; i++)
         {if((\*HT)[i].parent == 0)
              { if((\*HT)[i].weight < (\*HT)[min].weight)
                { min = i;
                }
              }
          } \*s1 = min;
          for(i = 1; i <= n; i++)
          { if((\*HT)[i].parent == 0 && i != (\*s1))
              { min = i;break;
              }
         }
          for(i = 1; i <= n; i++)
          {if((\*HT)[i].parent == 0 && i != (\*s1))
              { if((\*HT)[i].weight < (\*HT)[min].weight)
                  { min = i;
                  }
              }   \*s2 = min;
     }
      }
    //从叶子到根逆向求每个字符的哈夫曼编码
     void creatHuffmanCode(HuffmanTree HT,HuffmanCode HC,int n)
     {
         int i,j,c;
         int start;
         int f;
         HC=(HuffmanCode \*)malloc((n+1) * sizeof(char \*));//分配n个字符编码的头指针向量
         char \*cd=(char \*)malloc(n\*sizeof(char));//分配求编码的工作区间
         cd[n-1] = '\0';//从右向左逐位存放编码,先存放编码结束符
         for(i=1;i<=n;i++)//逐个字符求哈夫曼编码
         {      start = n - 1;
             for(c=i, f=HT[i].parent;f!=0;c=f, f=HT[f].parent)
             {      if(HT[f].lchild= =c)
                        cd[- -start]='0';
                 else
                        cd[- -start]='1';
              }
             HC[i]=(char \*)malloc((n - start) * sizeof(char));   //为第i个字符编码分配空间
             HT[i].length=n-start-1;//求编码长度
             strcpy(HC[i],&cd[start]);
         } free(cd);//释放工作空间
         for(i = 1;i <= n; i++)
         {
             printf("权值为 %3d对应字母为  %c 的叶子节点的哈夫曼编码是 %s 长度为 %d \n", HT[i].weight,HT[i].c,HC[i],HT[i].length); }
     }
     //定义编码解码函数
    void Translatecode(HuffmanTree HT,HuffmanCode HC,int n,char code[])
    {  int i,j,m,c,choice;
         int start;
         int f;
         char zcode[100];//存放输入的字母字符串
         m=2*n-1;
         HC=(HuffmanCode *)malloc((n+1)*sizeof(char *));//分配n个字符编码的头指针向量
         char *cd=(char *)malloc(n*sizeof(char));//分配求编码的工作区间
         cd[n-1] = '\0';//从右向左逐位存放编码,先存放编码结束符
         for(i=1;i<=n;i++)//逐个字符求哈夫曼编码
         {  start = n - 1;
             for(c=i, f=HT[i].parent;f!=0;c=f, f=HT[f].parent)
             {  if(HT[f].lchild=\=c)
                        cd[- -start]='0';
                 else
                        cd[- -start]='1';
              }
             HC[i]=(char \*)malloc((n - start) * sizeof(char));   //为第i个字符编码分配空间
             strcpy(HC[i],&cd[start]);
         }
         while(1)
        {  printf("\n是否进行编译操作。1-执行 2-退出:\n");
                scanf("%d",&choice);
                getchar();
                if(choice=\=1)
                    {   printf("请输入需要编码的字母字符串 :\n");
                    gets(zcode);
                     printf("编译好的二进制编码为:\n");
                     for(i=0;zcode[i]!='\0';i++)
                     for(j=1;j<=n;j++)
                     if(HT[j].c=\=zcode[i])
                     printf("%s",HC[j]);
                    }
                else  if(choice=\=2)
                     break;
        }
          while(1){  printf("\n是否进行解码操作。1-执行 2-退出\n");
                scanf("%d",&choice);
                if(choice=\=1)
                    {   j=0;
                     while(code[j]!='\0')
                     {  if(code[j]=\='0')
                           m=HT[m].lchild;
                         else    m=HT[m].rchild;
                         if(HT[m].lchild=\=0)//找到叶子节点m
                       {   printf("%c",HT[m].c);
                          m=2\*n-1;//回到根节点
                       }    j++;
                    }
                    getchar();
                      printf("\n原电码为:\n");
                     printf("%s",code);
                    printf("\n请输入已破译的电文:\n");
                          gets(zcode);
                     printf("反编译的电码为:\n");
                     for(i=0;zcode[i]!='\0';i++)
                     for(j=1;j<=n;j++)
                     if(HT[j].c=\=zcode[i])
                     printf("%s",HC[j]);
       printf("\n判断电文输入正确否  1-正确  2-错误:\n");
                   scanf("%d",&choice);
                        if(choice=\=1)
                            printf("\n电文输入正确!\n");
                  else  printf("\n电文输入错误!\n");  }
                else  if(choice=\=2)
                     break;}
    }
    //定义获取叶子节点权值和字母的函数
    void getcode(char ch[],int w[],int N[]){
        int i,j,count;
        int k=1;
        char temp;
        char zcode[50];//字母字符串
        printf("请输入字母字符串:\n");
        scanf("%s",zcode);
        for(i=0;zcode[i]!='\0';i++)
        {   if(zcode[i]=='*')
              continue;
              temp=zcode[i];
              count=0;
              for(j=i;zcode[j]!='\0';j++)
               { if(temp==zcode[j])
                 {   zcode[j]='*';
                    count++;
                 }
                 ch[k]=temp;//记录叶子节点代表的字母
                 w[k]=count;//权值为字母出现频率
               }
                k++;  }
        N[0]=k-1;}
     void main()
     {  HuffmanTree HT;
         HuffmanCode HC;//各叶子节点的哈夫曼编码
         char ch[30];//各叶子节点的字符代表
         char code[400]; //存放输入的二进制编码字符串
         int w[30];//w数组存储权值
         int i,j,n,m,c;
         int N[1];//当执行0号操作时,作用等价于n的值
          HC=(HuffmanCode *)malloc((n+1)*sizeof(char *));
         while(1)
         { printf("\n0-输入叶子节点个数(采用2号方法建树时使用)");  printf("\n1-输入字母字符创建哈夫曼树");//0号操作与1号操作选择一个
         printf("\n2-输入数据的权值和相应的字符代表创建哈夫曼树");
             printf("\n3-输入要破解的电文密码");
             printf("\n4-文件存储信息");
             printf("\n5-文件读取信息");
             printf("\n6-构建哈夫曼树并打印哈夫曼树");
             printf("\n7-求各叶子节点的哈夫曼编码");
             printf("\n8-进行编码译码");
             printf("\n请输入你要执行的操作:\n");
             scanf("%d",&c);
             switch(c)
             {  case 0:
                 printf("输入叶子节点个数 n:  " );
                      scanf("%d",&n);
                      m=2\*n-1;
                      break;
                 case 1:
                       getcode(ch,w,N);
                            n=N[0];
                           m=2\*n-1;
                      break;
                 case 2:
                      printf("\n请输入%d个数据的权值:\n",n);
                      for(i=1; i<=n; i++)
                         {   printf("%d: ",i);
                           fflush(stdin);//清空输入缓存区
                           scanf("%d",&w[i]);
                         }
                      printf("请输入%d个数据的字符代表:\n",n);
                      for(i=1;i<=n;i++)
                         {  printf("%d号为: ",i);
                            fflush(stdin);//清空输入缓存区
                            scanf("%c",&ch[i]);
                          }
                    break;
                 case 3:
                    printf("请输入要破解的电文二进制编码:\n");
                    scanf("%s",code);
                    break;
                 case 4:
                    save(n,w,code,ch);
                    break;
                 case 5:
                    read(n,w,code,ch);
                    break;
                 case 6:
                    createHuffmanTree(&HT,w,n,ch);
               printf("\n\*\*\**\*\*\*\*\*\*打印哈夫曼树\*\*\**\*\*\*\*\n");
         printf("序号\t字符\t权值\t双亲\t左孩子\t右孩子\n");
                    for(i=1;i<=m;i++)
                    printf("%d\t%c\t%d\t%d\t%d\t%d\t\n",i,HT[i].c,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);
                    break;
                 case 7:
                    creatHuffmanCode(HT,&HC,n);
                    break;
                 case 8:
                    Translatecode(HT,&HC,n,code);
                    break;
                 default: break;
             }
             if((c<0)||(c>8))
                 break;
        } }
    

    运行结果:首先进行输入节点信息并存储文件的方法构建哈夫曼树

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    由于太长只截取部分编码。完整编码为000000001010011111100000000101001111000011110110001111110101111000011001100110110111001111010000110110010011111011110110011111110010000100101110000010111101000110011

    保存文件
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    关闭程序,重新开始,此时选择读取文件方式构建哈夫曼树,文件hafuman.txt中存储着各叶子节点权值,对应字符和待编译的二进制编码,读取文件截图如下,其他操作6.7.8及结果同上。
    在这里插入图片描述
    给出另一种构建哈夫曼树的方法

    在这里插入图片描述
    字母个数为相应字母对应的权值
    在这里插入图片描述

    其他操作同输入节点建树或者读取文件建树相似,在此不再给出。

    展开全文
  • 数据结构实验报告 1?问题描述 已知n个字符在原文中出现的频率求它们的哈夫曼编码 2?问题分析 求哈夫曼编码首先要根据字符出现的频率即权值构建哈夫曼树然后 根据哈夫曼树求出哈夫曼编码 3.算法设计 创建哈夫曼树对n...
  • 数据结构完整实验报告 实验3:和二叉树的应用-哈夫曼编码设计
  • 哈夫曼编码

    千次阅读 2017-04-06 23:15:49
    哈夫曼编码(还有对应的实验报告,在我的上传资源里,可以免费下载)) 1.设计内容 1.添加用户登录密码 2.建立哈夫曼树:读入文件(*.souce),统计文件中字符出现的频度,并以这些字符的频度作为权值,...
  • 实验题目树和二叉树小组合作否姓名班级学号一...(3)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码产生方法。二.实验环境装有VisualC++6.0的计算机一台。三、实验内容与步骤1、二叉树遍历递归算法:假设二叉...
  • //动态分配数组存储哈夫曼树 /*****Huffman编码表结构定义*****/ typedef struct huffman_code { unsigned char len;//长度 unsigned char *codestr; }hufcode; typedef char **huffmancode;//动态分配数组...
  • 哈夫曼树的应用——课程设计

    千次阅读 多人点赞 2016-12-26 13:20:18
    这个是我去年的课程设计报告,因为有学弟要我就整理了下,功能很简单,就一个加密...以下是实验报告内容    哈夫曼树的应用——对文件进行解码和译码 一、 需求分析说明 随着信息时代的到来,信息越来越多,如何
  • 哈夫曼编码实现文件压缩实验报告 一、实验目的 1、了解文件的概念。 2、掌握线性链表的插入、删除等算法。 3、掌握Huffman的概念及构造方法。 4、掌握二叉树的存储结构及遍历算法。 5、利用Huffman及...
  • 淮海工学院计算机工程学院 实验报告书 课程名 算法分析与设计 题 目 实验3 贪心算法 哈夫曼编码 班 级 软件102班 学 号 11003215 姓 名 鹿迅 评语: 成绩 指导教师 批阅时间: 实验 3 贪心算法 实验目的和要求 1了解...
  • 哈夫曼编码 数据结构

    千次阅读 2018-05-29 13:11:57
    上周日做了数据结构实验报告,感觉还行。 一、课题描述  编制一个运用哈夫曼编码的相关知识对任意文本文件进行编码、解码,并保存相关结果的程序。 二、概要设计(主要思想应根据代码执行顺序了解) 1)...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

哈夫曼树编码实验报告