SWUST OJ 986: 哈夫曼译码

最新推荐文章于 2024-05-09 21:03:12 发布
最新推荐文章于 2024-05-09 21:03:12 发布
阅读量1.4k 收藏 9
点赞数 3
分类专栏： SWUST OJ 文章标签： 霍夫曼树 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56381917/article/details/116863164
版权

986: 哈夫曼译码

题目描述
通常要求根据给定的编码本对密文进行解码。现已给定相应字符的哈夫曼编码，要求根据编码对密文进行解码。（建立哈夫曼树以及编码、主函数等都已经给出，你只需要填写译码函数void ccode(haffnode hafftree[],int n)即可。

const int maxvalue=100;

const int maxbit=100;

const int maxn=100;

#include “iostream”

#include “stdio.h”

#include “stdlib.h”

using namespace std;

struct haffnode

{

char ch;

int weight;

int flag;

int parent;

int leftchild;

int rightchild;

};

struct code

{

int bit[maxn];

int start;

int weight;

char ch;

};

void haffman(int weight[],char text[],int n,haffnode hafftree[])

{

int j,m1,m2,x1,x2,i;

for(i=0;i< 2*n-1;i++)

{

if(i < n)

{

hafftree[i].weight=weight[i];

hafftree[i].

ch=text[i];

}

else

{

hafftree[i].weight=0;

hafftree[i].ch=’#’;

}

hafftree[i].parent=0;

hafftree[i].flag=0;

hafftree[i].leftchild=-1;

hafftree[i].rightchild=-1;

}

for(i=0;i< n-1;i++)

{

m1=m2=maxvalue;

x1=x2=0;

for(j=0;j< n+i;j++)

{

if(hafftree[j].weight< m1&&hafftree[j].flag==0)

{

m2=m1;

x2=x1;

m1=hafftree[j].weight;

x1=j;

}

else if(hafftree[j].weight< m2&&hafftree[j].flag==0)

{

m2=hafftree[j].weight; x2=j;

}

}

hafftree[x1].parent=n+i;

hafftree[x2].parent=n+i;

hafftree[x1].flag=1;

hafftree[x2].flag=1;

hafftree[n+i].weight=hafftree[x1].weight+hafftree[x2].weight;

hafftree[n+i].leftchild=x1; hafftree[n+i].rightchild=x2;

}

}

void haffmancode(haffnode hafftree[],int n,code haffcode[])

{

code cd; int i,j; int child,parent;

for( i=0;i< n;i++)

{

cd.start=n-1;

cd.weight=hafftree[i].weight;

cd.ch=hafftree[i].ch;

child=i;

parent=hafftree[child].parent;

while(parent!=0)

{

if(hafftree[parent].leftchild==child)

cd.bit[cd.start]=0;

else cd.bit[cd.start]=1;

cd.start–;

child=parent;

parent=hafftree[child].parent;

}

for(j=cd.start+1;j< n;j++)

haffcode[i].bit[j]=cd.bit[j];

haffcode[i].start=cd.start;

haffcode[i].weight=cd.weight;

haffcode[i].ch=cd.ch;

}

}

void ccode(haffnode hafftree[],int n)

{ }

int main( )

{

int n=8;

int weight[]={5,29,7,8,14,23,3,11};

char text[]={‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,‘h’};

haffnode myhafftree[maxvalue];

code myhaffcode[maxvalue];

haffman(weight,text,n,myhafftree);

haffmancode(myhafftree,n,myhaffcode);

ccode(myhafftree,n);

return 0;

}

输入

根据哈夫曼树编码表，针对字符串做好的编码结果。

输出

对每一行需要解码的串，进行解码，并输出解码后的结果。

样例输入

000100011011101110

样例输出

aabcc

思路：

  • 我对哈夫曼的理解是，把哈夫曼比作是一个密码小本本，我们只有按照小本本上面的东西来翻译才能把特殊密码翻译出来。这道题相当于把小本本给了我们，我们只需要读懂小本本的编码方式按部就班的解码就能得出答案，总的来说其实并不难。

由于题干中涉及到的只有哈夫曼解码，下面的内容中关于哈夫曼树的基本概念和构造方法只做简略介绍，重点讲解哈夫曼的解码过程：

  1. 解释题干中的代码（电脑喜欢的小本本）
const int maxvalue=100;
const int maxbit=100;
const int maxn=100;
#include "iostream"
#include "stdio.h"
#include "stdlib.h"
#include<string.h>
using namespace std;
struct haffnode
{
    char ch;
    int weight;
    int flag;
    int parent;
    int leftchild;
    int rightchild;
};
struct code
{
    int bit[maxn];
    int start;
    int weight;
    char ch;
};
//种哈夫曼树
void haffman(int weight[],char text[],int n,haffnode hafftree[])
{
    int j,m1,m2,x1,x2,i;
    //i、j是下标
    //m1，m2是两个最小值，更小的为左子树的值
    //较大的是右子树的值
    //x1是左子树，x2是右子树
    for(i=0;i<2*n-1;i++)
    {
        if(i < n)//前n个是叶子结点，有权值和结点值
        {
            hafftree[i].weight=weight[i];
            hafftree[i].ch=text[i];
        }
        else// [n,2*n-2] 是双亲结点，初始时没有权值，结点值置为‘#’号
        {
            hafftree[i].weight=0;
            hafftree[i].ch='#';
        }
        //每个结点的其余数据都置初值
        hafftree[i].parent=0;
        hafftree[i].flag=0;
        hafftree[i].leftchild=-1;
        hafftree[i].rightchild=-1;
    }
    for(i=0;i<n-1;i++)
    {
        m1=m2=maxvalue;
        //两个最小值置为最大值，待会好比较
        x1=x2=0;
        //左右子树
        for(j=0;j<n+i;j++)//从中取出两个权值最小的点
        {
            if(hafftree[j].weight< m1&&hafftree[j].flag==0)//并且未被访问
            {
                //遇到更小的m1（左子树权值）
                //则把前一个m1的值给m2，因为要满足左子树比右子树小
                m2=m1;
                x2=x1;
                m1=hafftree[j].weight;
                x1=j;
            }
            else if(hafftree[j].weight< m2&&hafftree[j].flag==0)
            {
                m2=hafftree[j].weight; x2=j;
            }
        }
            //选出两个子结点，构成一个父结点
            hafftree[x1].parent=n+i;
            hafftree[x2].parent=n+i;
            hafftree[x1].flag=1;//标志已访问
            hafftree[x2].flag=1;//标志已访问
            hafftree[n+i].weight=hafftree[x1].weight+hafftree[x2].weight;
            //父节点权重
            hafftree[n+i].leftchild=x1; hafftree[n+i].rightchild=x2;
            //父节点的左右子树
    }

}
//放哈夫曼编码
void haffmancode(haffnode hafftree[],int n,code haffcode[])
{
    code cd;//临时哈夫曼编码
    int i,j;
    int child,parent;
    for(i=0;i<n;i++)//一共n个叶子节点
    {
        cd.start=n-1;//从该叶子结点开始，从下往上遍历树
        cd.weight=hafftree[i].weight;
        cd.ch=hafftree[i].ch;
        child=i;
        parent=hafftree[child].parent;
        while(parent!=0)//从下往上，到根节点为止
        {
            //哈夫曼树转编码时，左子树为0，右子树为1
            if(hafftree[parent].leftchild==child)//当前子树是左子树
            cd.bit[cd.start]=0;
            else cd.bit[cd.start]=1;
            cd.start--;
            child=parent;//往上
            parent=hafftree[child].parent;
        }
        for(j=cd.start+1;j<n;j++)//从头开始设置该根节点的哈夫曼编码的值
        haffcode[i].bit[j]=cd.bit[j];

        haffcode[i].start=cd.start;
        haffcode[i].weight=cd.weight;
        haffcode[i].ch=cd.ch;
    }

}
//编译哈夫曼编码即我们要做的工作
void ccode(haffnode hafftree[],int n)
{

}

int main( )
{
    int n=8;
    int weight[]={5,29,7,8,14,23,3,11};
    char text[]={'a','b','c','d','e','f','g','h'};
    haffnode myhafftree[maxvalue];
    //最多maxvalue个哈夫曼结点构成一棵哈夫曼树
    code myhaffcode[maxvalue];
    haffman(weight,text,n,myhafftree);
    //先种哈夫曼树
    haffmancode(myhafftree,n,myhaffcode);
    //根据哈夫曼树来放哈夫曼编码
    ccode(myhafftree,n);
    //编译哈夫曼编码
    return 0;

}
  1. 根据题干画出哈夫曼树的逻辑结构（人类喜欢的小本本）
    在这里插入图片描述
  2. 哈夫曼解码：从根节点开始，左走零，右走一，走到叶子节点就输出，重复以上步骤至编码解完。
  3. 完整答案：
const int maxvalue=100;
const int maxbit=100;
const int maxn=100;
#include "iostream"
#include "stdio.h"
#include "stdlib.h"
#include<string.h>
using namespace std;
struct haffnode
{
    char ch;
    int weight;
    int flag;
    int parent;
    int leftchild;
    int rightchild;
};
struct code
{
    int bit[maxn];
    int start;
    int weight;
    char ch;
};
void haffman(int weight[],char text[],int n,haffnode hafftree[])
{
    int j,m1,m2,x1,x2,i;
    //i、j是下标
    //m1，m2是两个最小值，更小的为左子树的值
    //较大的是右子树的值
    //x1是左子树，x2是右子树
    for(i=0;i<2*n-1;i++)
    {
        if(i < n)//前n个是叶子结点，有权值和结点值
        {
            hafftree[i].weight=weight[i];
            hafftree[i].ch=text[i];
        }
        else// [n,2*n-2] 是双亲结点，初始时没有权值，结点值置为‘#’号
        {
            hafftree[i].weight=0;
            hafftree[i].ch='#';
        }
        //每个结点的其余数据都置初值
        hafftree[i].parent=0;
        hafftree[i].flag=0;
        hafftree[i].leftchild=-1;
        hafftree[i].rightchild=-1;
    }
    for(i=0;i<n-1;i++)
    {
        m1=m2=maxvalue;
        //两个最小值置为最大值，待会好比较
        x1=x2=0;
        //左右子树
        for(j=0;j<n+i;j++)//从中取出两个权值最小的点
        {
            if(hafftree[j].weight< m1&&hafftree[j].flag==0)//并且未被访问
            {
                //遇到更小的m1（左子树权值）
                //则把前一个m1的值给m2，因为要满足左子树比右子树小
                m2=m1;
                x2=x1;
                m1=hafftree[j].weight;
                x1=j;
            }
            else if(hafftree[j].weight< m2&&hafftree[j].flag==0)
            {
                m2=hafftree[j].weight; x2=j;
            }
        }
            //选出两个子结点，构成一个父结点
            hafftree[x1].parent=n+i;
            hafftree[x2].parent=n+i;
            hafftree[x1].flag=1;//标志已访问
            hafftree[x2].flag=1;//标志已访问
            hafftree[n+i].weight=hafftree[x1].weight+hafftree[x2].weight;
            //父节点权重
            hafftree[n+i].leftchild=x1; hafftree[n+i].rightchild=x2;
            //父节点的左右子树
    }

}

void haffmancode(haffnode hafftree[],int n,code haffcode[])
{
    code cd;//临时哈夫曼编码
    int i,j;
    int child,parent;
    for(i=0;i<n;i++)//一共n个叶子节点
    {
        cd.start=n-1;//从该叶子结点开始，从下往上遍历树
        cd.weight=hafftree[i].weight;
        cd.ch=hafftree[i].ch;
        child=i;
        parent=hafftree[child].parent;
        while(parent!=0)//从下往上，到根节点为止
        {
            //哈夫曼树转编码时，左子树为0，右子树为1
            if(hafftree[parent].leftchild==child)//当前子树是左子树
            cd.bit[cd.start]=0;
            else cd.bit[cd.start]=1;
            cd.start--;
            child=parent;//往上
            parent=hafftree[child].parent;
        }
        for(j=cd.start+1;j<n;j++)//从头开始设置该根节点的哈夫曼编码的值
        haffcode[i].bit[j]=cd.bit[j];

        haffcode[i].start=cd.start;
        haffcode[i].weight=cd.weight;
        haffcode[i].ch=cd.ch;
    }

}

void ccode(haffnode hafftree[],int n)
{
    int Treenode;
    char str[maxvalue];
    scanf("%s",str);
    int len=strlen(str);
    //此处长度不为n，长度为输入字符串的长度
    Treenode=2*n-2;
    for(int j=0;j<len;j++)
    {
        if(str[j]=='0')//为0，朝左分支走
        {
            Treenode=hafftree[Treenode].leftchild;
        }
        else if(str[j]=='1')//为1，朝右分支走
        {
            Treenode=hafftree[Treenode].rightchild;
        }
        if(hafftree[Treenode].leftchild==-1||hafftree[Treenode].rightchild==-1)
        //走到叶子结点即可输出符号
        {
            printf("%c",hafftree[Treenode].ch);
            Treenode=2*n-2;
        }
    }
}

int main( )
{
    int n=8;
    int weight[]={5,29,7,8,14,23,3,11};
    char text[]={'a','b','c','d','e','f','g','h'};
    haffnode myhafftree[maxvalue];
    //maxvalue个哈夫曼结点构成一棵哈夫曼树
    code myhaffcode[maxvalue];
    haffman(weight,text,n,myhafftree);
    //先得出哈夫曼树
    haffmancode(myhafftree,n,myhaffcode);
    //根据哈夫曼树来创建哈夫曼编码
    ccode(myhafftree,n);
    //打表
    return 0;

}

感谢西南科技大学->拉图的分享
以上方法仅供参考，欢迎互联网广大朋友们提出指正。

秋澄orange
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼编码算法源码(带有用于调试的代码)
愿君出走半生，归来时仍是少年
06-04 1284
该程序能统计 input.txt 文件中的所有字符出现的次数,并据此生成各个字符的哈夫曼编码,然后将这些信息写入 output.txt 文件中.(其中 input.txt 文件中的内容只能是键盘上的所有可显示字符和换行符)   #include #include #define MAXLEAFNUM 128 typedef struct node//二叉树的结点结构 { i
swust oj 986
abegvl6849的博客
04-15 1223
哈夫曼译码 1000(ms) 10000(kb) 1997 / 4186 通常要求根据给定的编码本对密文进行解码。现已给定相应字符的哈夫曼编码，要求根据编码对密文进行解码。（建立哈夫曼树以及编码、主函数等都已经给出，你只需要填写译码函数void ccode(haffnode hafftree[],int n)即可。 const int maxvalue=...
986: 哈夫曼译码
最新发布
2302_79277225的博客
05-09 1080
解法：先把代码粘贴到编译器（vs）上，分享一个一键去除空白行的操作，ctrl+f调出查找窗口，输入查找(?<=\r\n)\r\n，选择正则表达式，替换就可以发现会去掉一百多行空白行。算法就是：遍历i给定01串，j每次从下标2*n-2开始回溯到0，若达到叶子节点也就是左右孩子为空，则打印ht[j]且重置j，否则继续遍历。要看 得到的哈夫曼树是什么样子。一下子就可以画出哈夫曼树出来。要看 得到的哈夫曼译码表。译码（以a0001举例）
swust.oj986: 哈夫曼译码
xiaodaitongxue的博客
06-11 2529
986: 哈夫曼译码 题目描述 通常要求根据给定的编码本对密文进行解码。现已给定相应字符的哈夫曼编码，要求根据编码对密文进行解码。（建立哈夫曼树以及编码、主函数等都已经给出，你只需要填写译码函数void ccode(haffnode hafftree[],int n)即可。 输入 根据哈夫曼树编码表，针对字符串做好的编码结果。 输出 对每一行需要解码的串，进行解码，并输出解码后的结果。 样例输入 000100011011101110 样例输出 aabcc void ccode(haffnode hafft
SWUST数据结构--哈夫曼译码
CasT1R's Blog
08-28 521
const int maxvalue=100; const int maxbit=100; const int maxn=100; #include "iostream" #include "stdio.h" #include "stdlib.h" using namespace std; struct haffnode { char ch; int weight; int flag; ...
swust oj 1010:折半查找的实现.cpp
06-03
swust oj 1010:折半查找的实现.cpp
swust oj 1011:二叉排序树的实现和查找.cpp
06-03
swust oj 1011:二叉排序树的实现和查找.cpp
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
西南科技大学SWUST OJ 数据结构 查找排序相关题解 查找排序.zip
01-01
SWUST OJ：1009、1010、1011、1012、1013、1014、1015、1016、1077、1098、1099题答案
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
SWUST OJ： 971、972、973、975、976、977、978、979、980、981、982、983、984、985、986、987、1051、1052、1053、1105题答案
swust西南科技大学OJ数据结构80题答案
10-14
整理了西南科技大学OJ上的全部80道数据结构考试题目代码
哈夫曼编码
hisfox的博客
05-07 178
#include<bits/stdc++.h> using namespace std; struct node{//树结构体 int w;//权重(即该字符在文本中出现的次数） node *l; node *r;//左右子树 bool is;//是否是叶子节点 char c;//字符 }; struct cmp{ bool operator ...
哈夫曼译码器
阿里Darker
06-23 1052
#include #include #include #include #define N 27 #define TYPE int typedef struct { TYPE w; int f,l,r; }HNode,*Htree; typedef struct { char c; char code[10]; }Hcode, *Huffman; void creat_Huf
swustOJ哈弗曼编码（985）
u014769764的专栏
05-18 1229
这里先把哈弗曼树创建出来，在进行编码，因为书上那个数组做的代码看得头晕 #include<iostream> #include<stdlib.h> #include<limits.h> using namespace std; typedef struct node { char datax;//存字母，若只用下面的data存下标可能和组合后的权值冲突，...
SWUSTOJ #986 哈夫曼译码
qq_61328171的博客
05-02 829
它是通过出现概率（权值）来实现一颗哈夫曼树，出现频率最小的数在最下面，最高的在最上面，压缩了数据。由题目我们可以知道题目建立的哈夫曼树，然后我们在纸上画出来，写出每个字母的哈夫曼编码，直接打表。由此可见，我们要做这道题首先就是建一颗哈夫曼树，然后根据左0右1来查找。完成后，记得自己认认真真的去实现一遍哦。当然上述是标准的做法，但是。糊弄考试专用（bushi。
数据结构：哈夫曼树，哈夫曼编码与译码系统
热门推荐
idevede的博客
02-13 1万+
将文本文件利用哈夫曼树进行编码，存储成压缩文件
哈夫曼译码 swustoj
yyx的博客
05-22 2680
哈夫曼译码 1000(ms) 10000(kb) 1570 / 3422通常要求根据给定的编码本对密文进行解码。现已给定相应字符的哈夫曼编码，要求根据编码对密文进行解码。（建立哈夫曼树以及编码、主函数等都已经给出，你只需要填写译码函数void ccode(haffnode  hafftree[],int n)即可。const int maxvalue=100;const int maxbit=10...
swustoj493: postoffice
06-28
回答1：</h3><br/>swustoj493: postoffice 这个问题不是很清楚，不知道您想要什么样的回答。如果您是想问西南科技大学的oj系统中的题目编号为swustoj493的题目是什么，那么这道题目是关于模拟邮局的题目，需要模拟...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值