哈夫曼编码与译码

已于 2022-10-22 15:49:21 修改
阅读量2.3k 收藏 60
点赞数 11
文章标签： 算法 c语言 数据结构 霍夫曼树
于 2022-10-21 13:31:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51322481/article/details/127444523
版权

题目梗概

任务：从键盘接收一串电文字符，输出对应的哈夫曼编码。同时，能翻译由哈夫曼编码生成的代码串，输出对应的电文字符串。

①构造一棵哈夫曼树；

②实现哈夫曼编码，并用哈夫曼编码生成的代码串进行译码；

③程序中字符和权值是可变的，实现程序的灵活性。

设计思路

对于不理解哈夫曼编码的同学可以看看这篇博客

为了完成题设要求我们分成了三个阶段：

创建哈夫曼树
对哈夫曼树进的叶子节点行编码
读取代码串进行译码

代码解析

结构体部分

结构体这块有哈夫曼树的结构、输入的数据结构、编码存储结构三大结构体。(其实个人感觉结构体这块写的并不好😢)

typedef struct Node
{
    int weight;
    char data;
    int parent;
    int Lchild;
    int Rchild;
}Node;
​
typedef struct
{
    int number;
    char s;
}Data;
​
typedef struct
{
    char code[30];
    int cnt;
}codetype;

节点

通过比较大小得出两节点的父节点，并将两节点的父节点设置为该节点，该节点的左右孩子分别为当前最小值与次小值。最后可以链接成哈夫曼树。

for(int i = 0; i < n; i++)
{
    HT[i].parent = -1;
    HT[i].Lchild = -1;
    HT[i].Rchild = -1;
    HT[i].data = d[i].s;
    HT[i].weight =  d[i].number;
}
for(int i = n; i < 2*n-1; i++)
{
    HT[i].data = '#';
    HT[i].parent = -1;
    HT[i].Lchild = -1;
    HT[i].Rchild = -1;
    HT[i].weight = -1;
}
for(int i=n; i<2*n-1; i++)
    {
        int min = 99999;//最小值
        int cmin = 99999;//次小值
        int m = 0; c = 0;//记录最小值和次小值的下标
        for (int j = 0; j<i; j++)
        {
            if (HT[j].parent == -1)
                if (HT[j].weight<min)
                {
                    c = m;
                    cmin = min;
                    min = HT[j].weight;
                    m = j;
                }
                else if (HT[j].weight<cmin)
                {
                    cmin = HT[j].weight;
                    c = j;
                }
​
        }
        HT[i].weight = min + cmin;//hfmTree[m].weight+hfmTree[c].weight;
        HT[i].Lchild = m;
        HT[i].Rchild = c;
        HT[m].parent = i;
        HT[c].parent = i;
        HT[i].parent = -1;//新结点的双亲没有为-1

编码

编码的过程则是在我们构建的哈夫曼树上通过叶节点像树的根节点溯源的过程。只要当前节点的父节点不为-1(即父节点之上还有父节点的父节点)就进行判断，如若为父节点的左子树则填入’0’反之为’1’。但是我们这样溯源到根节点字符的编码是与真实相反的，这个时候就需要在填入的时候就反转(或者在输出的时候反向输出也可行)。

void code(Node *HT, codetype *codeFile, int n)
{
    int i, p, c;
    codetype S;
    for (i = 0; i<n; i++)//对N的字符进行编码
    {
        c = i;
        p = HT[c].parent;
        S.cnt = n;//把cnt的值初始化为N，后续再用数组(S->code[])存字符的编码时,倒着存
        S.code[n] = '\0';
        while (p != -1)
        {
            if (HT[p].Lchild == c)
                S.code[--S.cnt] = '0';
            else//否则存‘1’
                S.code[--S.cnt] = '1';
            c = p;
            p = HT[c].parent;
        }
​
        codeFile[i] = S;//第i个字符的编码存入codeFile
    }
}
///编码结束进行译码

译码

译码与编码的思想是一致的，本质上是编码的逆运算。

void Decode(Node *HT, int n)
{
    int m = 2*n-1, i, j=m-1;
    printf("请输入要译码的Huffman编码:\n");
    char str[100];
    scanf("%s", &str);
    char C;
    int len = strlen(str);
    for(i = 0; i<len; i++)
    {
        C = str[i];
        if(C == '0')
            j = HT[j].Lchild;
        else
            j = HT[j].Rchild;
        if(HT[j].Lchild == -1)
        {
            printf("%c", HT[j].data);
            j = m -1;
        }
    }
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
​
typedef struct Node
{
    int weight;
    char data;
    int parent;
    int Lchild;
    int Rchild;
}Node;
​
typedef struct
{
    int number;
    char s;
}Data;
​
typedef struct
{
    char code[30];
    int cnt;
}codetype;
​
char c;
int num = 0;
int n = 0;
Data d[100];
​
void creat_huffman();
void output(Node *HT);
void code(Node *HT, codetype *codeFile, int n);
void Decode(Node *HT, int n);
​
int main()
{
    creat_huffman();
    Node *HT = (Node*)malloc(sizeof(Node)*(2*n-1));
    for(int i = 0; i < n; i++)
    {
        HT[i].parent = -1;
        HT[i].Lchild = -1;
        HT[i].Rchild = -1;
        HT[i].data = d[i].s;
        HT[i].weight =  d[i].number;
    }
    for(int i = n; i < 2*n-1; i++)
    {
        HT[i].data = '#';
        HT[i].parent = -1;
        HT[i].Lchild = -1;
        HT[i].Rchild = -1;
        HT[i].weight = -1;
    }
//    for(int i = 0; i < 2*n-1; i++)
//    {
//        printf("---%d---\n", HT[i].weight);
//    }
    for(int i=n; i<2*n-1; i++)
    {
        int min = 99999;//最小值
        int cmin = 99999;//次小值
        int m = 0; c = 0;//记录最小值和次小值的下标
        for (int j = 0; j<i; j++)
        {
            if (HT[j].parent == -1)
                if (HT[j].weight<min)
                {
                    c = m;
                    cmin = min;
                    min = HT[j].weight;
                    m = j;
                }
                else if (HT[j].weight<cmin)
                {
                    cmin = HT[j].weight;
                    c = j;
                }
​
        }
        HT[i].weight = min + cmin;//hfmTree[m].weight+hfmTree[c].weight;
        //hfmTree[i].CH = ' ';//方便整体输出加个字符空格
        HT[i].Lchild = m;
        HT[i].Rchild = c;
        HT[m].parent = i;
        HT[c].parent = i;
        HT[i].parent = -1;//新结点的双亲没有为-1
    }
//    for(int i = 0; i < 2*n-1; i++)
//    {
//        printf("---%d---\n", HT[i].weight);
//    }
    output(HT);
    printf("各字符编码如下:\n");
    codetype *codeFile;
    codeFile = (codetype *)malloc(sizeof(codetype)*n);
    code(HT, codeFile, n);
    for (int i = 0; i<n; i++)
    {
        printf("%c字符的编码: ", HT[i].data);
        printf("%s", codeFile[i].code + codeFile[i].cnt);
        printf("\n");
    }
    Decode(HT, n);
}
​
​
void creat_huffman()
{
    Node *p;
    p = (Node*)malloc(sizeof(Node));
    p ->parent = NULL;
    int count[100] = {};
    while((c = getchar()) != '\n')                  ///读取输入的字符
    {
        num++;
        count[c-65]++;
    }
​
    for(int i=0; i<100; i++)
    {
        if(count[i] != 0)
        {
            d[n].number = count[i];
            d[n].s = char(i+65);
            n++;
        }
    }
​
}
/Huffman树构建完成
​
///打印哈夫曼树的结构
void output(Node *HT)
{
    printf("Huffman Tree List:\n");
    printf("Number\tData\tWeight\tParent\tLchild\tRchild\n");
    for(int i=0; i<2*n-1; i++)
    {
        printf("%d\t%c\t%d\t%d\t%d\t%d\n", i,HT[i].data, HT[i].weight,HT[i].parent, HT[i].Lchild, HT[i].Rchild);
    }
}
///对节点进行编码
void code(Node *HT, codetype *codeFile, int n)
{
    int i, p, c;
    codetype S;
    for (i = 0; i<n; i++)//对N的字符进行编码
    {
        c = i;
        p = HT[c].parent;
        S.cnt = n;//把cnt的值初始化为N，后续再用数组(S->code[])存字符的编码时,倒着存
        S.code[n] = '\0';
        while (p != -1)
        {
            if (HT[p].Lchild == c)
                S.code[--S.cnt] = '0';
            else//否则存‘1’
                S.code[--S.cnt] = '1';
            c = p;
            p = HT[c].parent;
        }
​
        codeFile[i] = S;//第i个字符的编码存入codeFile
    }
}
///编码结束进行译码
void Decode(Node *HT, int n)
{
    int m = 2*n-1, i, j=m-1;
    printf("请输入要译码的Huffman编码:\n");
    char str[100];
    scanf("%s", &str);
    char C;
    int len = strlen(str);
    for(i = 0; i<len; i++)
    {
        C = str[i];
        if(C == '0')
            j = HT[j].Lchild;
        else
            j = HT[j].Rchild;
        if(HT[j].Lchild == -1)
        {
            printf("%c", HT[j].data);
            j = m -1;
        }
    }
}

运行结果

运行结果

最后，期待大家在评论区在留言区留下问题或宝贵的改进建议。

杨夏同学
关注
  • 11
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Huffman编码和解码的C语言实现
09-10
本文对于如何实现这一编码和解码进行了描述，并给出了它们的C语言实现过程。
哈夫曼编码/译码器
Salt_ish的博客
11-05 2147
哈夫曼编码/译码，哈夫曼树，树形图打印
【数据结构与算法】Huffman编码/译码（C/C++）
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-03 7312
利用哈夫曼编码进行信息通讯可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码；在接收端将传来的数据进行译码(复原)。对于双工信道(即可以双向传输信息的信道)，每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编译码系统。
哈夫曼树&哈夫曼编码
qq_39957456的博客
08-28 669
哈夫曼树 Huffman Tree 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。 哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 假设7个叶子节点依次为2,4,18,7,9,5和8. (1) 从小到大排序为2,4,5,7,8,9,18 (2) 取最小两个节点向上构造2+4=6， (3)重新排序得，5,6,7,8,9,18 重复步骤(1)(2)(3)直至剩下一个根节点，.
数据结构——哈夫曼编码译码器
热门推荐
莉莉莉的博客
01-09 1万+
题目5: 哈夫曼编/译码器 [问题描述] 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。 [基本要求] 一个完整的系统应具有以下功能： 1、I：初...
7-2 哈夫曼编码译码
qq_28983957的博客
03-10 6530
先看题目： 编写一个哈夫曼编码译码程序。 按词频从小到大的顺序给出各个字符（不超过30个）的词频，根据词频构造哈夫曼树，给出每个字符的哈夫曼编码，并对给出的语句进行译码。 为确保构建的哈夫曼树唯一，本题做如下限定： （1）选择根结点权值最小的两棵二叉树时，选取权值较小者作为左子树。 （2）若多棵二叉树根结点权值相等，按先后次序分左右，先出现的作为左子树，后出现的作为右子树。 生成哈夫曼编码时，哈夫曼树左分支标记为0，右分支标记为1。 输入格式: 第一行输入字符个数n； 第二行到第n行输入相
哈夫曼编码和译码
Dear_mx的博客
11-10 1127
哈夫曼树的编码和译码(ASCII)
从键盘接收一串电文字符，输出对应的Huffman(哈夫曼)编码，同时，能翻译由Huffman编码生成的代码串，输出对应的电文字符串。
qq_64874743的博客
12-10 4150
要求 1.构造一棵Huffman树； 2.实现Huffman编码，并用Huffman编码生成的代码串进行译码 3.程序中字符串和权值是可变的，实现程序的灵活性。 算法分析 在电报通信中，电文是以二进制代码传送的。在发送时，需要将电文中的字符转换成二进制代码串，即编码；在接收时，要将收到的二进制代码转化为对应的字符序列，即译码。由于字符集中的字符被使用的频率是非均匀的，在传送电文时，要想使电文的总长尽可能短。因此，若对某字符集进行不等长的编码设计，则要求任意一个字...
HuffmanTree.rar_哈夫曼编码与译码
07-15
读SourceFile.txt文件，对出现的字母进行哈夫曼编码，输出编码表到Code.txt,并用构建得的编码对SourceFIle.txt进行编码。
哈夫曼树 哈夫曼编码与译码实现（c++）
10-11
信息论课程设计-哈夫曼编码。将英文字符的统计概率作为待编码节点权值。编程得出哈夫曼的码表；输入一段英文字符，利用码表对其编码、译码。显示整个流程
c++哈夫曼编码与译码
12-20
c++数据结构的哈夫曼编码与译码 学习c++数据结构 每个人都应该学会哈夫曼编码与译码 了解其原理
哈夫曼编码与译码器数据结构课程设计报告样本.doc
12-17
哈夫曼编码与译码器数据结构课程设计报告样本.doc
代码随想录算法训练营day53
最新发布
Mitakiyuki的博客
04-27 239
从前到后遍历。
算法训练营day21
wugong_true的博客
04-23 395
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
排序算法-快速排序
分享我的点点滴滴，在成长路上与你同行！
04-23 1065
排序算法-快速排序
【错题集-编程题】数组中的最长连续子序列（排序 + 模拟）
Elena's Blog
04-24 295
因为题目不要求位置连续，那么就可以直接想到排序（我把这一块理解错了，导致没有排序去做），接着就是简单的模拟。，然而实际上这道题目要求的是。小心处理数字相同的情况。
代码随想录算法训练营day40
weixin_43390031的博客
04-23 399
1为头，左子树节点个数为0，右子数节点个数为2，即dp[0]*dp[2]，2为头，dp[1]*dp[1]，3为头dp[2]*dp[0]。故对dp[i]，我们也考虑1到i为头节点的数量相加，dp[i]=dp[0]*dp[i-1]+dp[1]*dp[i-2]+…时间复杂度O(n^2)。(i-2)取最大值，综合讨论一下就是拆成i-j和j，然后比较dp[i-j]*j和(i-j)*j的最大值，这里因为dp[i-j]必须要进行至少拆成两个数，所以没有包含i-j，故我们还需要比较i-j，递推公式就是。
电文的编码和译码 任务：从键盘接收一串电文字符，输出对应的哈夫曼编码。同时，能翻译由哈夫曼编码生成的代码串，输出对应的电文字符串。 ①构造一棵哈夫曼树；②实现哈夫曼编码，并用哈夫曼编码生成的代码串进行译码；③程序中字符和权值是可变的，实现程序的灵活性。
03-26
实现代码如下： ①哈夫曼树的构造： ```python class Node: def __init__(self, value, freq): self.value = value self.freq = freq self.left = None self.right = None def construct_huffman_tree(freq_dict): nodes = [Node(value, freq) for value, freq in freq_dict.items()] while len(nodes) > 1: nodes = sorted(nodes, key=lambda x: x.freq) left_node, right_node = nodes.pop(0), nodes.pop(0) parent_node = Node(None, left_node.freq + right_node.freq) parent_node.left, parent_node.right = left_node, right_node nodes.append(parent_node) return nodes[0] ``` 其中，freq_dict是一个字典类型，记录每个字符出现的频率。 ②哈夫曼编码和译码： ```python class HuffmanCode: def __init__(self, freq_dict): self.freq_dict = freq_dict self.root = construct_huffman_tree(freq_dict) self.codes_dict = self._generate_codes_dict() def _generate_codes_dict(self): def dfs(node, path): if not node: return if node.value is not None: self.codes_dict[node.value] = path if node.left: dfs(node.left, path + "0") if node.right: dfs(node.right, path + "1") self.codes_dict = {} dfs(self.root, "") return self.codes_dict def encode(self, text): result = "" for ch in text: result += self.codes_dict[ch] return result def decode(self, code): result = "" node = self.root for bit in code: node = node.left if bit == "0" else node.right if node.value is not None: result += node.value node = self.root return result ``` 其中，_generate_codes_dict()函数通过遍历哈夫曼树，生成每个字符对应的哈夫曼编码。 ③完整代码： ```python class Node: def __init__(self, value, freq): self.value = value self.freq = freq self.left = None self.right = None def construct_huffman_tree(freq_dict): nodes = [Node(value, freq) for value, freq in freq_dict.items()] while len(nodes) > 1: nodes = sorted(nodes, key=lambda x: x.freq) left_node, right_node = nodes.pop(0), nodes.pop(0) parent_node = Node(None, left_node.freq + right_node.freq) parent_node.left, parent_node.right = left_node, right_node nodes.append(parent_node) return nodes[0] class HuffmanCode: def __init__(self, freq_dict): self.freq_dict = freq_dict self.root = construct_huffman_tree(freq_dict) self.codes_dict = self._generate_codes_dict() def _generate_codes_dict(self): def dfs(node, path): if not node: return if node.value is not None: self.codes_dict[node.value] = path if node.left: dfs(node.left, path + "0") if node.right: dfs(node.right, path + "1") self.codes_dict = {} dfs(self.root, "") return self.codes_dict def encode(self, text): result = "" for ch in text: result += self.codes_dict[ch] return result def decode(self, code): result = "" node = self.root for bit in code: node = node.left if bit == "0" else node.right if node.value is not None: result += node.value node = self.root return result freq_dict = {} text = input("请输入电文字符串：") for ch in text: freq_dict[ch] = freq_dict.get(ch, 0) + 1 huffman_code = HuffmanCode(freq_dict) code = huffman_code.encode(text) print("哈夫曼编码：", code) text_decode = huffman_code.decode(code) print("电文字符串：", text_decode) ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值