NOJ-哈夫曼编/译码器-西工大数据结构

最新推荐文章于 2021-06-12 16:41:33 发布
原创 最新推荐文章于 2021-06-12 16:41:33 发布 · 5.4k 阅读 · 81 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#NOJ #数据结构 #西工大

本文介绍了一个基于哈夫曼树的编码与译码实现方案，详细阐述了如何构建哈夫曼树，以及如何利用该树进行数据编码与解码的过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

    昨天老师讲完了哈夫曼书，回到宿舍就开始写，到今天才算是通过。题目如下：


    分析一下题目，首先要构建一个哈夫曼树，然后先输出编码，再根据编码进行译码并输出。

    构建哈夫曼树，就是取所有数据中权重最小的两个，组成一个小树，这个小树的权重就是这两个数据权重之和，然后反复进行这个操作（已成为叶节点的数据不再进行权重比较），就可以得到一课哈夫曼书。这里并没有用二叉链表来存储，而是使用了一种顺序结构（记录下左支右支和父节点位置），这样也可以实现。若输入：3   a   b   c   1   2   4，则可以构建出如下的哈夫曼树：


    而进行编码时只要找到需编码数据在树中位置，再循环判断当前节点是其父节点的左支还是右支，若是左支则记录0，右支记录1，直到当前节点为头结点，就可得到需编码数据编码的逆序，再将它反过来就是所求编码。a在上个哈夫曼树中编码如下图：


    而到解码时，只需要从头结点开始走，0走左支1走右支，直到走到叶节点为止，叶节点中数据就是所求数据。01在上个哈夫曼树中解码如下图：


    以下是我的实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct huffmanNode
{
    char data;
    int weight;
    int parent;
    int left;
    int right;
};

struct huffmanTree
{
    struct huffmanNode node[200];
    int n;
};

void run ();
void putInData (struct huffmanTree *T);
void clear (struct huffmanNode *node);
void createNewTree (struct huffmanTree *T);
int findTwoMin (struct huffmanTree *T,int *min1,int *min2,int *weight);
int getCode (int A[],struct huffmanTree *T);
void printCode (int A[],int length);
int getEnCode (int A[],char B[],struct huffmanTree *T,int length1);
void printEnCode (char B[],int length);

int main()
{
    run ();
    return 0;
}

void run ()
{
    struct huffmanTree T;
    putInData(&T);
    createNewTree (&T);

    int A[2000]={0},length1;
    length1=getCode (A,&T);
    printCode (A,length1);

    char B[2000]={0},length2;
    length2=getEnCode (A,B,&T,length1);
    printEnCode (B,length2);
}

void putInData (struct huffmanTree *T)
{
    int i,n;
    scanf ("%d",&(T->n));
    n=T->n;
    clear (&(T->node[0]));
    for (i=1;i<=n;i++)
    {
        clear (&(T->node[i]));
        getchar();
        T->node[i].data=getchar();
    }
    for (i=1;i<=n;i++)
    {
        scanf ("%d",&(T->node[i].weight));
    }
}

void clear (struct huffmanNode *node)
{
    node->data='\0';
    node->weight=0;
    node->parent=0;
    node->left=0;
    node->right=0;
}

void createNewTree (struct huffmanTree *T)
{
    int min1,min2,weight;
    while (findTwoMin (T,&min1,&min2,&weight))
    {
        ++(T->n);
        clear (&(T->node[T->n]));
        T->node[T->n].left=min1;
        T->node[T->n].right=min2;
        T->node[T->n].weight=weight;
        T->node[min1].parent=T->n;
        T->node[min2].parent=T->n;
    }
}

int findTwoMin (struct huffmanTree *T,int *min1,int *min2,int *weight)
{
    int i,n,m;
    int minWeight1=2147483647;
    int minWeight2=2147483647;
    for (i=1,n=T->n;i<=n;i++)
    {
        if (!(T->node[i].parent))
        {
            m=T->node[i].weight;
            if (m<minWeight2)
            {
                if (m>minWeight1)
                {
                    minWeight2=m;
                    *min2=i;
                }
                else
                {
                    minWeight2=minWeight1;
                    minWeight1=m;
                    *min2=*min1;
                    *min1=i;
                }
            }
        }
    }
    if ((minWeight1!=2147483647)&&(minWeight2!=2147483647))
    {
        *weight=T->node[*min1].weight+T->node[*min2].weight;
        return 1;
    }
    else
    {
        return 0;
    }
}

int getCode (int A[],struct huffmanTree *T)
{
    int length=0,n,i,j,parent;
    char s[200]={0};
    getchar ();
    gets (s);
    n=strlen (s);
    for (i=n-1;i>=0;i--)
    {
        for (j=1;j<=T->n;j++)
        {
            if (s[i]==T->node[j].data)
            {
                parent=j;
                break;
            }
        }
        while (T->node[parent].parent)
        {
            if (T->node[T->node[parent].parent].left==parent)
            {
                A[length]=0;
            }
            else
            {
                A[length]=1;
            }
            length++;
            parent=T->node[parent].parent;
        }
    }
    return length-1;
}

void printCode (int A[],int length)
{
    int i;
    for (i=length;i>=0;i--)
    {
        printf ("%d",A[i]);
    }
    printf ("\n");
}

int getEnCode (int A[],char B[],struct huffmanTree *T,int length1)
{
    int i,length2=0,cur,head;
    head=T->n;
    for (i=length1,cur=head;i>=0;i--)
    {
        if (A[i])
        {
            cur=T->node[cur].right;
            if (!(T->node[cur].right))
            {
                B[length2]=T->node[cur].data;
                length2++;
                cur=head;
            }
        }
        else
        {
            cur=T->node[cur].left;
            if (!(T->node[cur].left))
            {
                B[length2]=T->node[cur].data;
                length2++;
                cur=head;
            }
        }
    }
    return length2-1;
}

void printEnCode (char B[],int length)
{
    int i;
    for (i=0;i<=length;i++)
    {
        printf ("%c",B[i]);
    }
    printf ("\n");
}

    以下是各函数的注释： 

void run ()
{
    struct huffmanTree T;
    putInData(&T);//输入数据
    createNewTree (&T);//构建哈夫曼树

    int A[2000]={0},length1;
    length1=getCode (A,&T);//得到编码
    printCode (A,length1);//输出编码

    char B[2000]={0},length2;
    length2=getEnCode (A,B,&T,length1);//得到解码
    printEnCode (B,length2);//输出解码
}

void putInData (struct huffmanTree *T)
{
    int i,n;
    scanf ("%d",&(T->n));//输入数据个数
    n=T->n;
    clear (&(T->node[0]));//节点初始化
    for (i=1;i<=n;i++)//循环输入数据
    {
        clear (&(T->node[i]));
        getchar();
        T->node[i].data=getchar();
    }
    for (i=1;i<=n;i++)//循环输入权重
    {
        scanf ("%d",&(T->node[i].weight));
    }
}
void clear (struct huffmanNode *node)
{
    node->data='\0';//初始化都设为0
    node->weight=0;
    node->parent=0;
    node->left=0;
    node->right=0;
}
void createNewTree (struct huffmanTree *T)
{
    int min1,min2,weight;
    while (findTwoMin (T,&min1,&min2,&weight))//如果能找出最小的两个权重的数据所在位置，就循环
    {
        ++(T->n);//创建新节点
        clear (&(T->node[T->n]));//新节点初始化
        T->node[T->n].left=min1;//新节点左支赋值
        T->node[T->n].right=min2;//新节点右支赋值
        T->node[T->n].weight=weight;//新节点权重赋值
        T->node[min1].parent=T->n;//最小权重的父赋值
        T->node[min2].parent=T->n;//第二小权重的父赋值
    }
}
int findTwoMin (struct huffmanTree *T,int *min1,int *min2,int *weight)
{
    int i,n,m;
    int minWeight1=2147483647;
    int minWeight2=2147483647;
    for (i=1,n=T->n;i<=n;i++)//循环判断每一个节点
    {
        if (!(T->node[i].parent))//若其无头结点（无头结点说明其未组成小树）
        {
            m=T->node[i].weight;
            if (m<minWeight2)//判断是否最小或第二小，并赋值
            {
                if (m>minWeight1)
                {
                    minWeight2=m;
                    *min2=i;
                }
                else
                {
                    minWeight2=minWeight1;
                    minWeight1=m;
                    *min2=*min1;
                    *min1=i;
                }
            }
        }
    }
    if ((minWeight1!=2147483647)&&(minWeight2!=2147483647))//如果找到
    {
        *weight=T->node[*min1].weight+T->node[*min2].weight;//权重赋值
        return 1;//返回真，循环继续
    }
    else/如果未找到
    {
        return 0;//返回假，循环停止
    }
}
int getCode (int A[],struct huffmanTree *T)//编码
{
    int length=0,n,i,j,parent;
    char s[200]={0};
    getchar ();
    gets (s);//得到需编码数据串
    n=strlen (s);//得到其长度
    for (i=n-1;i>=0;i--)//循环每一个数据元素
    {
        for (j=1;j<=T->n;j++)//在树中寻找到其位置
        {
            if (s[i]==T->node[j].data)
            {
                parent=j;
                break;
            }
        }
        while (T->node[parent].parent)//如果它无父，说明到达头结点，结束，否则继续循环
        {
            if (T->node[T->node[parent].parent].left==parent)//如果是左支
            {
                A[length]=0;//记录0
            }
            else//同上
            {
                A[length]=1;
            }
            length++;//编码记录数组长度加一
            parent=T->node[parent].parent;
        }
    }
    return length-1;//返回编码记录数组最后一个数据的位置
}
void printCode (int A[],int length)
{
    int i;
    for (i=length;i>=0;i--)//逆序输出编码记录数组
    {
        printf ("%d",A[i]);
    }
    printf ("\n");
}
int getEnCode (int A[],char B[],struct huffmanTree *T,int length1)//解码
{
    int i,length2=0,cur,head;
    head=T->n;
    for (i=length1,cur=head;i>=0;i--)//循环编码记录数组每一个数据
    {
        if (A[i])//如果是1
        {
            cur=T->node[cur].right;//走右支
            if (!(T->node[cur].right))//如果本节点是叶节点
            {
                B[length2]=T->node[cur].data;//记录解码数据
                length2++;//解码记录数组长度加一
                cur=head;//从头开始
            }
        }
        else//同上
        {
            cur=T->node[cur].left;
            if (!(T->node[cur].left))
            {
                B[length2]=T->node[cur].data;
                length2++;
                cur=head;
            }
        }
    }
    return length2-1;//返回解码记录数组最后一个数据的位置
}
void printEnCode (char B[],int length)
{
    int i;
    for (i=0;i<=length;i++)//输出解码记录数组
    {
        printf ("%c",B[i]);
    }
    printf ("\n");
}


    以上就是我的实现，希望给大家带来帮助。




    


哈夫曼编/译码器-数据结构课设
TheSevenSky
12-31 4376
哈夫曼编/译码器 前言 这是我上学期数据结构花了两天写的东西,有些地方写的比较仓促 但是功能的实现是完整的,并且有良好的界面 可以压缩图片音乐等等. 且压缩完了变成一个压缩文件随时可以解压 今天时间挺多的就整理一下发出来 供大家借鉴 并且使用的java版本 但是没有使用什么高难度的东西, 也都是很基础的东西 然后界面是用工具生成的代码 那些代码你可以忽视了 文章目录哈夫曼编/译码器前言界面...
西工大NOJ数据结构理论——013.以十字链表为存储结构实现矩阵相加（严5.27）
a15735748145a的博客
04-03 2517
西工大NOJ数据结构理论——013.以十字链表为存储结构实现矩阵相加（严5.27）
数据结构哈夫曼编译码器
11-29
上机报告哈夫曼编码是一种常用的数据压缩技术，对数据文件进行哈夫曼编码可大大缩短文件的传输长度，提高信道利用率及传输效率。要求采用哈夫曼编码原理，统计文本文件中字符出现的词频，以词频作为权值，对文件进行哈夫曼编码以达到压缩文件的目的，再用哈夫曼编码进行译码解压缩。
哈夫曼编码译码器（数据结构）
12-09
用C++实现的哈夫曼编译码器，可以实现创建哈夫曼树、对txt文件进行编码、译码，也可以查看生成的哈夫曼树。数据结构作业参考之必备品。
数据结构-基本算法-哈夫曼编译码器
05-21
数据结构-基本算法-哈夫曼编译码器(学生时代源码，调试可运行)
数据结构课程设计——哈夫曼编/译码器
11-26
有以下功能： 初始化 从终端读入字符集大小n及n个字符和m个权值，建立哈夫曼树，并将它存于文件hfmtree中 编码 利用已建好的哈夫曼树（如不在内存，则从文件hfmtree中读入），对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中 解码 利用已建好的哈夫曼树将文件codefile中的代码进行译码，结果存入文件textfile中 打印 将文件codefile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件codeprint中 打印哈夫曼树 将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件treeprint中 附带详细的设计报告（最后的课程设计等级被评定为优秀）
数据结构课程设计（哈夫曼编译码器 ）
07-20
非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）非常完美的数据结构课程设计（哈夫曼编译码器 ）
西北工业大学数据结构noj_1-6题
04-27
在“西北工业大学数据结构noj_1-6题”中，我们可以推测这是一系列与数据结构相关的编程练习题目，旨在帮助学生理解和应用各种数据结构。以下是基于这些题目可能涵盖的一些关键知识点的详细解释： 1. **线性数据结构...
西北工业大学 人工智能程序设计 Python NOJ-noj西工大
12-20
本文所提及的“Python NOJ-noj西工大”指的是西北工业大学推出的在线评测系统（Online Judge），用于对学生在编程能力上的训练和测试。 “NOJ”通常指的就是在线评测系统，它为学生提供了一个编程练习的平台，可以...
西北工业大学 人工智能程序设计 Python NOJ-西工大noj
最新发布
12-21
西北工业大学推出的“人工智能程序设计 Python NOJ”是一个面向学生的在线编程练习和评估平台，旨在提高学生在Python编程语言方面的实际操作能力，同时培养解决问题的逻辑思维。该平台可能是西北工业大学计算机科学...
哈夫曼编码/译码器数据结构课程设计
12-26
设计一个哈夫曼编码/译码系统，对一个文本文件中的字符进行哈夫曼编码，生成编码文件（后缀名.cod）；反过来，可将一个编码文件还原为一个文本文件(.txt)。 要求： （1）输入一个待编码的文本文件名，统计文本文件中各字符的个数作为权值，生成哈夫曼树； （2）将文本文件利用哈夫曼树进行编码，生成编码文件（后缀名cod）； （3）输入一个待解码的编码文件名称，并利用相应的哈夫曼树将编码文件译码； （4）显示指定的编码文件和文本文件； （5）把哈夫曼编码用二进制位紧缩到一个变量中，利用位运算进行真正的数据压缩，并求压缩比。（此选项选作）
哈夫曼编码/译码器 完整版课程数据结构设计
05-07
文本处理是现代化计算机应用的重要领域。文本由字符组成，字符以某种编码形式存储在计算机中。每个字符的编码可以是相等长度的，也可以是不等长度的。我们熟知的ASCII编码是等长编码。为了提高存储和处理文本的效率，在一些计算机应用场合，如数据通信，常采用不等长的编码，对常用的字符用较少的码位编码，不常出现的字符用较多的码位编码，从而减少文本的存储长度。哈夫曼编码就是用于此目的的不等长编码方法。当然，编码的对面就有译码。本课题中，首先是构造哈夫曼树。给定一组权值，以此作为叶结点的权值，可以构造多棵扩充二叉树，它们通常具有不同的加权路径长度。其中具有最小加权路径长度的扩充二叉树，用于构造高效的不等长编码。哈夫曼给出了构造具有最小加权路径长度的扩充二叉树的算法，称位哈夫曼算法。用哈夫曼算法构造的扩充二叉树称为哈夫曼编码树或哈夫曼树。当然，还有编码和译码部分。本系统的前端开发工具是Visual C++6.0。具有输入字符集大小及权值大小，构造哈夫曼树，并对用户输入的字符串进行编码以及译码还有退出四种功能。本程序经过测试后，功能均能实现，运行稳定。
noj实验3.1 哈夫曼编/译码器
qq_51053940的博客
05-24 1349
这是本人参考教材以后完成的，感觉这题难度不算很大，但是需要注意的细节较为多一点。 #include #include #define N 100 //字符集大小最多为100个 #define M 2*N-1 //最多产生的节点个数 #define max_weight 10000 //设置的最大权值 using namespace std; typedef struct //定义哈夫曼树的结构体变量 { int weight; int parent; int LChild; i
[NOJ]数据结构实验3.1 哈夫曼编/译码器
weixin_53028247的博客
05-14 1910
[NOJ]数据结构实验3.1 哈夫曼编码器 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct HTNode { int weight; int parent,lchild,rchild; char data; }HTNode; typedef struct HCNode { int bit[200]; int start; }HCNode; HTNode ht[1
NOJ数据结构实验007——哈夫曼编/译码器
weixin_53068269的博客
04-30 3664
本题简单思路： 1.先建立一棵哈夫曼树，在建立时需要将叶结点对应的字符记录在树中。 2.我们需要建立一套译码系统，将叶结点中存储字符对应的译码存储到字符串数组hc中。建立时，我们需要从叶结点开始进行记录，即从下到上，我们将每次得到的译码先存储在字符串cd中（cd长度不会超过叶结点个数），并且时从cd最后（结束符\0前）开始记录（因为之前是反的，负负得正），之后整合在hc中。 3.之后我们要在建立一套反译码系统。众所周知，哈夫曼编码是前缀编码，所以我们只需要将记录报文的字符串code与刚才字符串数组hc中每.
【数据结构实验】NOJ007 实验3.1 哈夫曼编/译码器
weixin_45932570的博客
05-18 1489
1. 题目 示例输入 5 a b c d e 12 40 15 8 25 bbbaddeccbbb 示例输出 00011111110111010110110000 bbbaddeccbbb 2. 代码 上课不听讲，写代码火葬场。 //5 a b c d e 12 40 15 8 25 //bbbaddeccbbb #include <iostream> #include <string> using namespace std; #define MAX 100 //定义
数据结构实验-哈夫曼编/译码器-NOJ7
迢遥的呼唤的博客
06-12 940
写一个哈夫曼码的编/译码系统，要求能对要传输的报文进行编码和解码。构造哈夫曼树时，权值小的放左子树，权值大的放右子树，编码时右子树编码为 1，左子树编码为0。 输入表示字符集大小为 n（n <= 100）的正整数，以及 n 个字符和 n 个权值（正整数，值越大表示该字符出现的概率越大）；输入串长小于或等于 100 的目标报文。 输出：经过编码后的二进制码，占一行； 以及对应解码后的报文，占一行； 最后输出一个回车符。 题目很明确，实现哈夫曼树的各种操作。此题还是有一定难度的，完整代码如下，关键部分有注
哈夫曼编码与解码
qq_45831414的博客
11-19 825
纪念我逝去的三天时间： 被 堆溢出 这个Bug困扰了许久，甚至开始怀疑编译器有问题 在经历了艰难险阻后 （其实最后发现只是少写个 1 终于解决了问题 代码如下： #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct HFM_Tree_Node { double weight; //用来存放各个结点的权值 unsigned int parent, LChild, RChild;
数据结构实验3：哈夫曼编 \ 译码器
qq_42110967的博客
05-31 1873
//哈夫曼编\译码器 #include <stdio.h> #include <stdlib.h> #define maxbit 10 #define max 1000 typedef struct HNode{ int weight; int parent,lchild,rchild; }HNode;/*哈夫曼树节点*/ typedef struct table{ int w[max]; char s[max]; int num; }.
西工大NOJ最新C/C++程序设计答案汇总
5. 西工大NOJ：结合“西工大”和“NOJ”两个关键词，我们可以推断这是一个由西北工业大学提供的在线编程评测平台，它可能是专门针对其计算机科学与技术专业学生或者编程爱好者开放的，允许用户进行C/C++等编程语言的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值