赫夫曼树与赫夫曼编码

最新推荐文章于 2022-11-15 21:20:27 发布
最新推荐文章于 2022-11-15 21:20:27 发布
阅读量738 收藏 8
点赞数 3
分类专栏： # 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44598153/article/details/88960105
版权

赫夫曼树——最优二叉树

书本上百度上均有解释其特点，在此不再一一道来，就由一道题目做索引，直接来谈谈它的构建过程吧额。

赫夫曼编码

时间限制: 1 Sec | 内存限制: 128 MB

输入
输入包含多组数据（不超过100组）
每组数据第一行一个整数n，表示字符个数。接下来n行，每行有一个字符ch和一个整数weight，表示字符ch所对应的权值，中间用空格隔开。
输入数据保证每组测试数据的字符不会重复。
输出
对于每组测试数据，按照输入顺序输出相应的字符以及它们的哈弗曼编码结果，具体格式见样例。

样例输入
3
A 10
B 5
C 8
4
A 1
B 1
C 1
D 1
样例输出
A:0
B:10
C:11
A:00
B:01
C:10
D:11

Huffman树的构建

大致思路 就是一次次的寻找最小权值结点构成一个二叉树，同时父结点将两子结点的权值相加并插入，然后将父结点的权值插入到权值数组里，如此重复的 查找结点、生成二叉树、插入结点，直到数组里只剩下最后一个结点，它就是这棵赫夫曼树的根结点。

构建过程

首先这里有一个权值数组,将其存入到一棵树的叶子结点里
在这里插入图片描述
选出两个权值最小的结点构成一棵简单的二叉树，父结点权值即为两者之子结点之和
在这里插入图片描述
随后将其父结点插入到结点数组里
在这里插入图片描述
再次选择结点，构建二叉树，插入结点， 重复操作，直到只剩下一个结点。
在这里插入图片描述
在这里插入图片描述
如图所示，最终结点就是这棵树的根结点，赫夫曼树构建完毕。

当时看完书之后思路很清晰啊，就一头扎进去开始写代码，中间也遇到了不少的错误，最后结合别人的博客文章、视频课程、书本，才将其顺利实现。

构建过程代码如下
//构建哈夫曼树
void CreateHuffmanTree(HuffmanTree &HT, int w[], int n)
{
	//赫夫曼结点数 
    int m = 2 * n - 1;
    //选取两个最小权值的结点
    int s1;
    int s2;
    int i;
    //为树结点分配内存 这里从1忽略了0号元素 
    HT = (HuffmanTree)malloc((m + 1) * sizeof(Node));
	//初始化树叶结点 
    for(i = 1; i <= n; i++)
    {
        HT[i].weight = w[i];
        HT[i].lchild = 0;
        HT[i].parent = 0;
        HT[i].rchild = 0;
    }
    //非叶子结点的初始化 
    for(i = n + 1; i <= m; i++)
    {
        HT[i].weight = 0;
        HT[i].lchild = 0;
        HT[i].parent = 0;
        HT[i].rchild = 0;
    }
    //创建非叶子结点即开始构建赫夫曼树
    for(i = n + 1; i <= m; i++)
    {
        Select(HT, i-1, &s1, &s2);
        //选出的两个权值最小的叶子结点组成一个新的二叉树
		//根为 i 结点
        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;
    }
}

完成了赫夫曼树的构建，就要用它做点正事了，由此开始探讨 赫夫曼编码的生成 。

首先了解一下什么是赫弗曼编码——其实就是前缀码的生成，只不过这里要保证每一个生成的前缀码都不是其他编码的前缀，这就可以引入上述探讨得出的赫夫曼树了。

为什么赫夫曼树可以用来生成这样的前缀码呢？

我的理解：

  1. 因为赫夫曼树为每一个权值分配了一条路径，从根结点到某一权值结点的路径上不会出现其他其他权值结点，其实也就是最初的权值结点都成为了最终赫夫曼树的叶子结点。

  2. 赫夫曼树中所有叶结点的带权路径长度之和——WPL，它的值是比较小的，这也就是它被称作最优二叉树的原因。
    在这里插入图片描述

这一特性使其生成的编码不会彼此间的前缀，而且长度非常的短。

赫夫曼编码的生成

我们可以将 左路径设置为 0，右路径设置为 1， 依次将每条路径上的0，1编码存入字符数组里；
在这里插入图片描述
在上图中的赫夫曼树，从根结点出发，一次向叶结点探索，如果要得到A的前缀码，路径为 右——右，因此它的编码即为 11。
再如 11 010 10 011 00 ,它的译码即为 ABCDE。

这里应题目要求，提供了一个逆向生成的赫夫曼编码

代码段如下
//开始逆向生成赫夫曼编码
void CreatHuffmanCode(HuffmanTree &HT, HuffmanCode *HC, char *name, int n)
{
    int i;
    //编码的起始指针
    int start;
    //标记父结点 
    int p;
	//标记子结点 
    unsigned int c;
    //给n个编码的分配头指针
    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;
        //从叶子到根结点求编码
        for(c = i, p = HT[i].parent; p != 0; c = p, p = HT[p].parent)
        {
        	//从右到左的顺序编码入数组内
            if( HT[p].lchild == c)
                 cd[--start] = '0';  //左分支标0
            else
            	cd[--start] = '1';  //右分支标1
        }
        //为第i个编码分配空间并保存生成的编码 
        HC[i] = (char *)malloc((n - start) * sizeof(char));
        strcpy(HC[i], &cd[start]);
    }
    //释放cd开始下一组编码的生成 
    free(cd);
    //打印编码序列
    for(i = 1; i <= n; i++)
         printf("%c:%s\n", name[i], HC[i]);
}

不多喷了， 这道题题完整的AC代码是这样的

#include<stdio.h>
#include<string.h>
#include<stdlib.h> 
//haffman 树的结构
typedef struct
{
    //叶子结点权值
    unsigned int weight;
    //指向双亲，和孩子结点的指针
    unsigned int parent;
    unsigned int lchild;
    unsigned int rchild;
} Node, *HuffmanTree;
//这里选择了动态分配数组
typedef char *HuffmanCode;
//找出两个最小权值结点并用指针带回 
void Select(HuffmanTree HT, int n, int *s1, int *s2)
{
    int i = 0;
    int 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指向
    *s1 = min;
	//重复操作注意s1的干扰 
    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 CreateHuffmanTree(HuffmanTree &HT, int w[], int n)
{
	//赫夫曼结点数 
    int m = 2 * n - 1;
    //选取两个最小权值的结点
    int s1;
    int s2;
    int i;
    //为树结点分配内存 这里从1忽略了0号元素 
    HT = (HuffmanTree)malloc((m + 1) * sizeof(Node));
	//初始化树叶结点 
    for(i = 1; i <= n; i++)
    {
        HT[i].weight = w[i];
        HT[i].lchild = 0;
        HT[i].parent = 0;
        HT[i].rchild = 0;
    }
    //非叶子结点的初始化 
    for(i = n + 1; i <= m; i++)
    {
        HT[i].weight = 0;
        HT[i].lchild = 0;
        HT[i].parent = 0;
        HT[i].rchild = 0;
    }
    //创建非叶子结点即开始构建赫夫曼树
    for(i = n + 1; i <= m; i++)
    {
        Select(HT, i-1, &s1, &s2);
        //选出的两个权值最小的叶子结点组成一个新的二叉树
		//根为 i 结点
        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;
    }
}
//开始逆向生成赫夫曼编码
void CreatHuffmanCode(HuffmanTree &HT, HuffmanCode *HC, char *name, int n)
{
    int i;
    //编码的起始指针
    int start;
    //标记父结点 
    int p;
	//标记子结点 
    unsigned int c;
    //给n个编码的分配头指针
    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;
        //从叶子到根结点求编码
        for(c = i, p = HT[i].parent; p != 0; c = p, p = HT[p].parent)
        {
        	//从右到左的顺序编码入数组内
            if( HT[p].lchild == c)
                 cd[--start] = '0';  //左分支标0
            else
            	cd[--start] = '1';  //右分支标1
        }
        //为第i个编码分配空间并保存生成的编码 
        HC[i] = (char *)malloc((n - start) * sizeof(char));
        strcpy(HC[i], &cd[start]);
    }
    //释放cd开始下一组编码的生成 
    free(cd);
    //打印编码序列
    for(i = 1; i <= n; i++)
         printf("%c:%s\n", name[i], HC[i]);
}
int main(void)
{
    HuffmanTree HT;
    HuffmanCode HC;
    int *w, i, n, m;
    char *name;
    while(~scanf("%d", &n)) 
    {
	    w=(int *)malloc((n+1)*sizeof(int));
	    name=(char *)malloc((n+1)*sizeof(char));
	    for(i=1; i<=n; i++)
	    {
	    	getchar();
	        scanf("%c %d",&name[i], &w[i]);
	    }
	    CreateHuffmanTree(HT, w, n);
	    CreatHuffmanCode(HT, &HC, name, n);   	
	}
    return 0;
}

注释：

首先、
这篇博客里的些许内容借鉴了其他人的文章，毕竟数据结构的题目无论是设计，还是Debug，都太费劲了， 我选择了 最优路径。。。。。（流汗）

第二、
自从学习树的第一讲开始，就意识到以后的数据结构也会愈渐复杂，遇到的问题解决起来会越来越费劲，有些东西实现起来简直是肝到爆，一次次的调试更是弄得人心态爆炸，但不管怎么说——不能草草了事。

最后、
老规矩，AC了就赶紧睡觉， 头发最重要。。。。。。。

IIRELIA
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c语言 赫夫曼树和编码（哈夫曼树和编码）
jiangjun_feng的博客
05-11 408
运行结果正确 感觉最难的是树的合并 #include<stdio.h> #include <stdlib.h> #include <string.h> #include<malloc.h> //构造哈夫曼树 typedef struct { int val; int parent,left,right; }node,*tree; //构造哈夫曼编码 typedef struct{ int weight; int code[10]; }code_nod
DS二叉树--赫夫曼树的构建与编码
半途行走的博客
10-23 2793
题目描述 给定n个权值，根据这些权值构造huffman树，并进行huffman编码 参考课本算法，注意数组访问是从位置1开始 要求：赫夫曼的构建中，默认左孩子权值不大于右孩子权值 输入 第一行输入t，表示有t个测试实例 第二行先输入n，表示第1个实例有n个权值，接着输入n个权值，权值全是小于1万的正整数 依此类推 输出 逐行输出每个权值对应的编码，格式如下：权值-编码 即每行先输出1个权值，再输...
#POJ1521#Huffman编码
ElaineZXY的博客
07-01 772
[POJ1521]Huffman编码 时间限制: 1 Sec  内存限制: 128 MB 题目描述 输入一个字符串，长度不超过100，仅由大写字母和下划线分组成。求用最好的字符编码方式，令总长度最小。 输入 多组数据，每组数据在一行上输入一个字符串，格式如前所述 当遇到END时，表示输入结束。 输出 对应每个输入，在一行上输出3个信息：首先是
哈夫曼树的基本概念及其构建（C++）
最新发布
smart_jackli的博客
11-15 1747
哈夫曼树的基本概念及其构建
DS树--带权路径和
hhhertzzz的博客
11-05 539
题目描述 计算一棵二叉树的带权路径总和，即求赫夫曼树的带权路径和。 已知一棵二叉树的叶子权值，该二叉树的带权案路径和APL等于叶子权值乘于根节点到叶子的分支数，然后求总和。如下图中，叶子都用大写字母表示，权值对应为：A-7，B-6，C-2，D-3 树的带权路径和 = 71 + 62 + 23 + 33 = 34 本题二叉树的创建参考前面的方法 输入 第一行输入一个整数t，表示有t个二叉树 第二行输入一棵二叉树的先序遍历结果，空树用字符‘0’表示，注意输入全是英文字母和0，其中大写字母表示叶子 第三行.
DS二叉树--赫夫曼树的构建与编码（含代码框架）
wwgqck的博客
12-24 830
DS二叉树–赫夫曼树的构建与编码（含代码框架） 题目描述 给定n个权值，根据这些权值构造huffman树，并进行huffman编码 参考课本算法，注意数组访问是从位置1开始 要求：赫夫曼的构建中，默认左孩子权值不大于右孩子权值 代码框架参考如下： 输入 第一行输入t，表示有t个测试实例 第二行先输入n，表示第1个实例有n个权值，接着输入n个权值，权值全是小于1万的正整数 依此类推 输出 逐行输出每个权值对应的编码，格式如下：权值-编码 即每行先输出1个权值，再输出一个短划线，再输出对应编码，接着下一行输入下
【id:179】【20分】C. DS二叉树--赫夫曼树的构建与编码（不含代码框架）
White--Night的博客
11-06 911
即每行先输出1个权值，再输出一个短划线，再输出对应编码，接着下一行输入下一个权值和编码。第二行先输入n，表示第1个实例有n个权值，接着输入n个权值，权值全是小于1万的正整数。给定n个权值，根据这些权值构造huffman树，并进行huffman编码。P147算法6.12 HuffmanCoding代码。要求：赫夫曼的构建中，默认左孩子权值不大于右孩子权值。逐行输出每个权值对应的编码，格式如下：权值-编码。第一行输入t，表示有t个测试实例。，注意数组访问是从位置1开始。
Huffman 压缩解压缩 Java实现
08-31
使用Java 语言实现了Huffman编码的压缩和解压缩，能够实现对Ascii 文档的压缩和解压缩，目前尚不支持对二进制文档进行压缩
赫夫曼编码
05-11
赫夫曼编码对数据的压缩很有作用，大约可以压缩20%~90%,主要由文件的数据特性决定的！这里是赫夫曼编码的具体实现，主要借助二叉树和优先队列来实现最优前缀编码，也就是赫夫曼编码，赫夫曼
NYOJ 801-Haffman编码（丧心病狂的输入格式）
s0il的博客
03-08 339
题目描述: 哈弗曼编码大家一定很熟悉吧（不熟悉也没关系，自己查去。。。）。现在给你一串字符以及它们所对应的权值，让你构造哈弗曼树，从而确定每个字符的哈弗曼编码。当然，这里有一些小规定： 1.规定哈弗曼树的左子树编码为0，右子树编码为1； 2.若两个字符权值相同，则ASCII码值小的字符为左孩子，大的为右孩子； 3.创建的新节点所代表的字符与它的左孩子的字符相同； 4.所有字符为ASCII...
DS二叉树——Huffman编码与解码（不含代码框架）
luoyeliufeng的博客
12-20 730
DS二叉树——Huffman编码与解码（不含代码框架） 题目描述 1、问题描述 给定n个字符及其对应的权值，构造Huffman树，并进行huffman编码和译（解）码。 构造Huffman树时，要求左子树根的权值小于、等于右子树根的权值。 进行Huffman编码时，假定Huffman树的左分支上编码为‘0’，右分支上编码为‘1’。 2、算法 构造Huffman树算法： ⑴ 根据给定的n个权值(w1...
赫夫曼树+赫夫曼编码小结
smietao的博客
08-24 612
赫夫曼树+赫夫曼编码——《大话数据结构》读书笔记
【数据结构】 赫夫曼树与赫夫曼编码
路先生的杂货铺，学习总结+好文分享
09-30 1233
赫夫曼树 一、什么是赫夫曼树？ 如果给出一个学生的成绩从百分之转化为五级制，若使用ifelse则代码过于冗余，我们可以使用赫夫曼树的形式完成它： 但是出于查找更高效的考虑，我们可以将树构建成这样： 这样效率又高了不少。 二、赫夫曼树的定义与原理 我们将上面这颗二叉树简化成带权二叉树： 从树中一个节点到另一个节点之间的分支构成两个节点之间的路径，路径上的分支数目称做路径长度。 如a中根节点到D的路径长度为4，b中到D的路径长度为2 树的路径长度就是从树根到每一节点的路径长度之和。 a的树路径长度就为1+
赫夫曼树、赫夫曼编码
qq_54429571的博客
09-10 410
赫夫曼树：概念、创建原理、代码实现。赫夫曼编码：概念、定长编码、变长编码、赫夫曼编码。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值