霍夫曼（Huffman）树创建算法详解之C语言版

已于 2022-11-20 13:43:39 修改
阅读量1.8k 收藏 27
点赞数 6
分类专栏： 算法与数据结构 文章标签： 算法 c语言 数据结构
于 2022-10-17 16:18:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunnyoldman001/article/details/127365766
版权

一、Huffman树

霍夫曼(Huffman)树又称最优树，是一类带权路径长度最短的树，在众多领域中有着广泛的应用，尤其是信息编码。Huffman树的主要用处就是对数据进行编码，得到0-1码流，以实现快速传输，此编码也称为Huffman编码。本文主要给出了Huffman树的创建过程及相应的算法实现。
树的权路径长度是树上全部结点到树根的权路径长度之和。例如有如下一棵树，结点B、E和K的路径长度是1，C、D、F和G的路径长度是2，H和I的路径长度是3，J的路径长度是4，假设每个结点的权均是1，则该树的权路径长度为
WPL = 3×1+4×2+2×3+1×4 = 21
在这里插入图片描述
现在考虑二叉树，给每个树叶结点都赋予权值，则树叶的权值乘以路径长度就得到了每个树叶结点的权路径长度，所有树叶结点的权路径长度之和就是该二叉树的权路径长度。由于现在考虑的是有限结点的二叉树，因此由这些树叶结点所组成的全部二叉树中，一定存在一个权路径长度为最小的一棵，此树即为Huffman树。
例如：如下图给出的三个叶子结点的权分别是1,2和3的二叉树：
在这里插入图片描述
每一棵二叉树的权路径长度分别为：
图（a）：WPL = 1×2+2×2+3×2 = 12
图（b）：WPL = 3×1+1×2+2×2 = 9
图（c）：WPL = 2×1+1×2+3×2 = 10
图（d）：WPL = 1×1+2×2+3×2 = 11
由此可以看出图（2）中的二叉树对应的WPL值最小，其为Huffman树。

二、Huffman树的创建过程示例

给定一组数据：E, A, B, C, B, A, E, D, B, C, E, E, E, D, C, E, B, A, B, C，根据此数据创建一棵Huffman树。
构建Huffman树的过程如下：
Step 1： 统计每个元素出现的频数（按照字母出现的次序统计）：
在这里插入图片描述
Step 2：以这些频数作为每个数据的权，创建Huffman树。
在这里插入图片描述
**1）**找出最小的二个权，生成一个二叉树（左小右大），二个权之和5作为二叉树的树根，把权值2和3从权序列这个删除，将5加入，得到新的权：
在这里插入图片描述
**2）**找出当前权中最小的两个权，继续生成一棵二叉树（遇到权值相同，则单个权值优先）：
在这里插入图片描述
**3）**找出当前权中最小的两个权，继续生成一棵二叉树：
在这里插入图片描述
**4）**找出当前权中最小的两个权，继续生成一棵二叉树：
在这里插入图片描述

至此，就得到了一棵Huffman树，该Huffman树的权路径长度为：
WPL = 6×2+4×2+5×2+2×3+3×3 = 45.

三、Huffman树的创建流程

前面给出了Huffman树的创建过程，为了方便实现创建Huffman树，引入了结构体数组，用来存储Huffman树结点信息，并用结构数组存储Huffman树全部的结点。则前述的Huffman树创建过程可以用数组实现如下：
准备工作：生成一个结构体数组，存储全部权，数组元素个数为权个数的2倍减1。并将每一个权对应结点的双亲、左子树、右子树的序号置为-1：
在这里插入图片描述
Step 1：找到权值（有背景色）最小的两个3和2相加得到5，存到下标为5的元素中，并将下标5的左子树的下标赋值为4，右子树下标赋值为1，将下标4和1中的双亲下标赋值为5.
在这里插入图片描述
Step 2：在剩下的权值（有背景色）中找到权值最小的两个5和4相加得到9，存到下标为6的元素中，并将下标6的左子树的下标赋值为3，右子树下标赋值为2，将下标3和2中的双亲下标赋值为6.
在这里插入图片描述
Step 3：在剩下的权值（有背景色）中找到权值最小的两个5和6相加得到11，存到下标为7的元素中，并将下标7的左子树的下标赋值为5，右子树下标赋值为0，将下标5和0中的双亲下标赋值为7.
在这里插入图片描述
Step 4：在剩下的权值（有背景色）中找到权值最小的两个9和11相加得到20，存到下标为8的元素中，并将下标8的左子树的下标赋值为6，右子树下标赋值为7，将下标6和7中的双亲下标赋值为8.
在这里插入图片描述

四、创建Huffman树算法的C程序

1.存储Huffman树结点的结构体

typedef struct HTree
{
	char cChar;
	int  Weight; 
	int  Parent;
	int  LChild;
	int  RChild;
}HuffmanTree;

2.创建Huffman树的算法之C程序

//存储字符及字符出现次数(权值)的结构体
typedef struct charStat
{
	char c;
	int  num;
}CharStat;

/*******************************************************************************
void HTreeCreation( CharStat *cStat, HuffmanTree *TreeNode, int codeNum )
功能：创建Huffman树
输入：cStat：存储统计结果的数组，每个元素包括2项，分别是字符、次数
      codeNum：不同字符的个数
输出：TreeNode：Huffman树的结点
返回值：无
********************************************************************************/
void HTreeCreation( CharStat *cStat, HuffmanTree *TreeNode, int codeNum )
{
	int i, j, k;
	int w1, w2, p1, p2;
	int nodeNum;
	nodeNum = 2 * codeNum - 1;

	for( i=0; i<nodeNum; i++ )//initial HuffmanTree
	{
		if( i < codeNum )
		{
			TreeNode[i].cChar  = cStat[i].c;
			TreeNode[i].Weight = cStat[i].num;
		}
		else
		{
			TreeNode[i].cChar  = '\0';
			TreeNode[i].Weight = 0;
		}
		TreeNode[i].LChild = BLANKFLAG;
		TreeNode[i].RChild = BLANKFLAG;
		TreeNode[i].Parent = BLANKFLAG;
		
	}
	//找最小的两个权生成一棵子树，存储到第一个非叶子结点，依此，直到只剩下一个结点
	for( j=codeNum; j<nodeNum; j++ )
	{
		w1 = 0xFFFFFFF;
		w2 = w1;
		p1 = p2 = BLANKFLAG;
		for( k=0; k<j; k++ )
		{
			if( TreeNode[k].Weight < w1 && TreeNode[k].Parent == BLANKFLAG )
			{
				w1 = TreeNode[k].Weight;
				p1 = k;
			}
		}
		for( k=0; k<j; k++ )
		{
			if( TreeNode[k].Weight < w2 && k != p1  && TreeNode[k].Parent == BLANKFLAG )
			{
				w2 = TreeNode[k].Weight;
				p2 = k;
			}
		}
		TreeNode[j].Weight  = w1 + w2;
		TreeNode[j].LChild  = p1;
		TreeNode[j].RChild  = p2;
		TreeNode[p1].Parent = j;
		TreeNode[p2].Parent = j;
	}
}//HTreeCreation

3.完整的测试代码
从键盘读入一个字符串，统计每个字符出现的次数，并据此创建Huffman树。

#include"stdio.h"
#include"string.h"

#define MAX_NODE 100
#define BLANKFLAG  -1

//存储从键盘或者文件读入的字符串。
typedef struct charLinkList
{
	char cChar;
	struct charLinkList *pNext;
}CharLinkList;

//存储字符及字符出现的次数(权值)
typedef struct charStat
{
	char c;
	int  num;
}CharStat;
//Huffman树的结点信息，其中前n个为叶子结点
typedef struct HTree
{
	char cChar;
	int  Weight; 
	int  Parent;
	int  LChild;
	int  RChild;
}HuffmanTree;

//获取字符串，并存储到以str为表头的单链表中
void getStr( CharLinkList &str, int &cNum );
//统计每个字符及出现的次数
void cStatInf( CharLinkList str, int cTotalNum, CharStat *cStat, int &codeNum );
//生成Huffman树
void HTreeCreation(  CharStat *cStat, HuffmanTree *TreeNode, int codeNum );

int main()
{
	int i;
	CharLinkList str, *p;
	CharStat     *cStat;
	int cTotalNum, codeNum;

	//从键盘获取待编码的字符串
	printf( "Please input a string which need to be encoded:\n" );
	getStr( str, cTotalNum );
	
	//统计待编码字符串中不同字符及其出现的次数
	cStat = new CharStat[ cTotalNum ];
	cStatInf( str, cTotalNum, cStat, codeNum );
	//向屏幕输出待编码字符串中的字符信息
	printf( "the code infomation in string:\n" );
	printf( "char : num\n" );
	for( i=0; cStat[i].c != '\0'; i++ )
	{
		if( cStat[i].c == ' ' )
			printf( "空格 : %d\n", cStat[i].num );
		else
			printf( "%3c  : %d\n", cStat[i].c, cStat[i].num );
	}

	//根据待编码字符串中不同字符的信息创建Huffman树
	//Huffman树的结点存储在结构体数组treeNode中
	HuffmanTree *treeNode;
	int nodeNum = 2 * codeNum - 1;
	treeNode = new HuffmanTree[nodeNum];
	HTreeCreation(  cStat, treeNode, codeNum );
	//向屏幕输出Huffman树结点信息，包括 序号、字符、权、双亲序号、左孩子序号、右孩子序号
	printf( "Huffman Tree's node infomation:\n" );
	printf( "%s%s%4c%4c%4c%4c\n", "num ", "Code", 'W', 'P', 'L', 'R'  );
	for( i=0; i<nodeNum; i++ )
	{
		printf( "%3d%5c%4d%4d%4d%4d\n", i, treeNode[i].cChar, treeNode[i].Weight, treeNode[i].Parent, treeNode[i].LChild, treeNode[i].RChild  );
	}
	return 0;
}

/*******************************************************************************
void getStr( CharLinkList &str, int &cTotalNum )
功能：从键盘读入一个待编码的字符串，回车结束输入
输入：str：存储字符串的首地址，单链表
输出：cTotalNum：字符串中全部字符的个数
返回值：无
********************************************************************************/
void getStr( CharLinkList &str, int &cTotalNum )
{
	CharLinkList *node, *p;
	char ch;

	cTotalNum  = 0;
	p = &str;
	//每读入一个字符，即刻存储到一个单链表里面
	while( 1 )//尾插入法创建单链表
	{
		ch = getchar();
		if( ch == '\n' )
			break;
		cTotalNum++;
		node        = new CharLinkList;
		node->cChar = ch;
		node->pNext = NULL;
		p->pNext    = node;
		p           = node;
	}
}//getStr

/*******************************************************************************
void cStatInf( CharLinkList str, int cTotalNum, CharStat *cStat, int &codeNum )
功能：统计每个字符及出现的次数
输入：str：引用，存储字符串的首地址
      cTotalNum：字符串中全部字符的个数
输出：cStat：存储统计结果的数组，每个元素包括2项，分别是字符、次数
      codeNum：不同字符的个数
返回值：无
********************************************************************************/
void cStatInf( CharLinkList str, int cTotalNum, CharStat *cStat, int &codeNum )
{
	int i, j;
	CharLinkList *p;
	int loc;     //记录全新字符存储的位置号
	int newFlag; //新字符标记，如果是第一次出现，则该标志置为1，否则为0

	p = str.pNext;
	for( i=0; i<cTotalNum; i++ )
	{
		cStat[i].c   = '\0';
		cStat[i].num = 0;
	}
	
	loc = 0;
	//从第一个字符开始统计不同的字符出现的次数
	while( p != NULL )
	{
		newFlag = 1;//每读一个字符，都假设是第一次出现
		//获取一个新位置上的字符，如果在此位置之前已经出现了，则计数器自加后结束本轮的查新
		for( j=0; cStat[j].c != '\0'; j++ )
		{
			if( cStat[j].c == p->cChar )
			{
				newFlag = 0;
				cStat[j].num++;
				break;    
			}
		}
		//如果获取的新位置上的字符，在此位置之前没有出现，则存放到第一个空白位置
		if( newFlag == 1 )
		{
			cStat[loc].c = p->cChar;
			cStat[loc].num++;
			loc++;
		}
		p = p->pNext;
	}
	codeNum = loc++;
}//cStatInf

/*******************************************************************************
void HTreeCreation( CharStat *cStat, HuffmanTree *TreeNode, int codeNum )
功能：创建Huffman树
输入：cStat：存储统计结果的数组，每个元素包括2项，分别是字符、次数
      codeNum：不同字符的个数
输出：TreeNode：Huffman树的结点
返回值：无
********************************************************************************/
void HTreeCreation( CharStat *cStat, HuffmanTree *TreeNode, int codeNum )
{
	int i, j, k;
	int w1, w2, p1, p2;
	int nodeNum;
	nodeNum = 2 * codeNum - 1;

	for( i=0; i<nodeNum; i++ )//initial HuffmanTree
	{
		if( i < codeNum )
		{
			TreeNode[i].cChar  = cStat[i].c;
			TreeNode[i].Weight = cStat[i].num;
		}
		else
		{
			TreeNode[i].cChar  = '\0';
			TreeNode[i].Weight = 0;
		}
		TreeNode[i].LChild = BLANKFLAG;
		TreeNode[i].RChild = BLANKFLAG;
		TreeNode[i].Parent = BLANKFLAG;
		
	}
	//找最小的两个权生成一棵子树，存储到第一个非叶子结点，依此，直到只剩下一个结点
	for( j=codeNum; j<nodeNum; j++ )
	{
		w1 = 0xFFFFFFF;
		w2 = w1;
		p1 = p2 = BLANKFLAG;
		for( k=0; k<j; k++ )
		{
			if( TreeNode[k].Weight < w1 && TreeNode[k].Parent == BLANKFLAG )
			{
				w1 = TreeNode[k].Weight;
				p1 = k;
			}
		}
		for( k=0; k<j; k++ )
		{
			if( TreeNode[k].Weight < w2 && k != p1  && TreeNode[k].Parent == BLANKFLAG )
			{
				w2 = TreeNode[k].Weight;
				p2 = k;
			}
		}
		TreeNode[j].Weight  = w1 + w2;
		TreeNode[j].LChild  = p1;
		TreeNode[j].RChild  = p2;
		TreeNode[p1].Parent = j;
		TreeNode[p2].Parent = j;
	}
}//HTreeCreation

4.测试结果
在这里插入图片描述

笑看峰云
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树合集（二）：霍夫曼树(图文详解)
Viper的程序员修炼手册
06-25 5162
1 前言 霍夫曼树是二叉树的一种特殊形式，又称为最优二叉树，其主要作用在于数据压缩和编码长度的优化。 2 重要概念 2.1 路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。 图2.1 图2.1所示二叉树结点A到结点D的路径长度为2，结点A到达结点C的路径长度为1。 2.2 结点的权及带权路径长度 若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权
C语言实现最优二叉树——霍夫曼（Huffman）树算法
菜鸟学C/C++
04-07 1万+
赫夫曼（Huffman）树又称最优二叉树或最优搜索树，是一种带权路径长度最短的二叉树。在许多应用中，常常赋给树中结点一个有某种意义的实数，称此实数为该结点的权。从树根结点到该结点之间的路径长度与该结点上权的乘积称为结点的带权路径长度(WPL)，树中所有叶子结点的带权路径长度之和称为该树的带权路径长度，通常记为：
创建霍夫曼树，霍夫曼编码以及使用霍夫曼编码压缩文件
m0_62809339的博客
04-26 1100
那么，什么是霍夫曼树（赫夫曼树）呢？ 给定n个权值（权值就是每个节点里面存放的数据，但是根据业务需求不同，存放的数据类型有些差别）作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 看这个定义你肯定也很懵，我这里举一个例子，就不要专研这个定义了，通过图形可以很快的看懂 例如：权值分别为 5,3，9,1,6的这几个节点构建一颗二叉树 首先排序这样创建的二叉树才是有序的 那么排序的结果.
C语言huffman编码实现常见文件压缩算法
06-25
通过二进制流读入文件，然后以字节计算统计的方式进行文件的压缩，压缩算法使用huffman，
【数据结构】霍夫曼树
最新发布
m0_74055118的博客
04-21 872
霍夫曼树（Huffman Tree），又称最优二叉树，是一种带权路径长度最短的二叉树。在霍夫曼树中，叶子节点的权值通常代表字符出现的频率，非叶子节点的权值是其子节点权值的和。霍夫曼树广泛应用于数据压缩，尤其是霍夫曼编码，它是一种基于字符出现频率的变长前缀编码。：首先，将给定的字符和它们对应的权值（频率）放入一个集合中。：每次从集合中选出两个具有最小权值的节点，将它们合并成一个新节点，新节点的权值是这两个子节点权值的和。：将选出的两个最小权值节点从集合中删除，并将新创建的节点添加到集合中。
数据结构树--＞霍夫曼树
路漫漫其修远兮
08-12 7482
霍夫曼树 1. 霍夫曼树的定义 霍夫曼树又称最优二叉树。了解霍夫曼树之前先了解几个名词， 节点的权：若将树中的节点赋给一个有某种含义的值，这个值称为节点的权。 路径：从一个节点到另一个节点之间的分支构成两个节点之间的路径。 路径的长度：路径上的分支数量。 树的路径长度：从树的根到树中每一个节点的路径长度之和。 节点的带权路径长度：从该节点到树根之间的路径长度与节点上权的乘积。 树的带权路径长度：树中所有叶子节点的带权路径长度之和。 上图是个霍夫曼树，其中。 节点的权： A:7 B:5 C:2
数据结构与算法之Huffman tree(赫夫曼树 / 霍夫曼树 / 哈夫曼树 / 最优二叉树)
热门推荐
努力让自己发光，对的人才能迎着光而来
09-05 1万+
赫夫曼树概述 定义 构造赫夫曼树步骤 代码实现
数据结构(十二) -- 树(四) -- 霍夫曼树
weixin_39724194的博客
09-20 2312
通信领域中信息的处理方式：定长编码：变长编码：目前存在匹配的多意性，比如10010110100，我们是理解成10 0 101 10 100，但是机器也能理解成1 0 0。。。。霍夫曼编码注意：在获取字符出现次数时，可能出现重复的情况，但是这个不影响，我们生成的霍夫曼的树不一样，但是树的权（WPL）还是一样的，也就是压缩效率还是一致的。
树 - Huffman树的建立与Huffman编码的形成（C语言）
biaogexf
04-20 4042
Huffman树的存储结构：结构数组。Huffman树形成的关键：如何在一堆带权节点中每次选取两个权值最小的节点。1.哈夫曼树哈夫曼树又称最优二叉树。它是 n 个带权叶子结点构成的所有二叉树中，带权路径长度 WPL 最小的二叉树。如下图为一哈夫曼树示意图。2、构造哈夫曼树假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为：(1) 将w...
详解Huffman编码算法之Java实现
08-31
Huffman编码是一种高效的无损数据压缩算法，它利用字符出现的频率进行编码，频率高的字符用较短的二进制编码，频率低的字符用较长的编码，从而达到压缩数据的目的。这种编码方法特别适用于文本数据，因为文本中的...
C语言版的哈夫曼树.zip
11-10
哈夫曼树（Huffman Tree），也称为最优二叉树，是数据压缩技术中的关键概念。它是基于哈夫曼编码...通过实践C语言版的哈夫曼树，你不仅可以加深对数据结构的理解，还能锻炼编程能力，为解决实际问题打下坚实的基础。
基于huffman算法的图像编码 c语言版
12-01
2. **构造Huffman树**：基于这些频率创建一个优先队列（最小堆），然后逐步构建Huffman树。每次从队列中取出两个频率最低的节点合并为一个新的内部节点，并将新节点的频率设为这两个子节点的频率之和，将新节点入队...
Huffman压缩算法C语言实现
08-22
2. **创建Huffman树**：根据字符频率表，构造Huffman树。这个过程包括多次合并频率最小的两个节点，直到只剩下一个节点为止。这一步可以通过优先队列（如最小堆）来实现。 3. **生成编码**：从Huffman树的根节点...
matlab算法源码MATLAB霍夫曼Huffman编码译码带GUI
04-13
matlab算法源码MATLAB霍夫曼Huffman编码译码GUI界面设计源程序代码提取方式是百度网盘分享地址
求Huffman树的带权路径长度
魚肉的博客
11-30 1万+
这种方法并不是毫无道理，应为同一个结点下的两个叶子结点的路径长度是一样的，叶子结点的路径长度完全可以反映到其双亲结点上去。2.数组末尾两个元素求和（俩结点的双亲结点权值），将其结果放在数组倒数第二个位置上并且数组长度减1。这种算法较为简单，直接可以忽略建树的步骤，直接求出WPL（当然要明白如何求WPL）注意：当集合元素过小时不适用本算法，需要特殊处理，不然会发生数组越界。1.首先将得到的元素集合进行排序；升序也行，请自己尝试）3.累加每次求和结果。（即就是非叶子结点的权值）
m数据结构 day11 树（五） 霍夫曼树（最优二叉树），霍夫曼编码（压缩编码鼻祖算法）
wulimmya的博客
07-31 1811
文章目录最基本的压缩编码方法：霍夫曼编码 最基本的压缩编码方法：霍夫曼编码 计算机和网络技术中，文本，图像，音频数据的压缩是非常重要的技术。压缩之后，数据占用的磁盘空间减少，在网络中传输的时间也能减少。但是文本的压缩决不能出错，图像和音频可以进行有损压缩，但是文本必须是无损压缩。 现在已经有很多更新的更好的压缩技术，但这都来源于技术的积累，压缩编码的鼻祖，是霍夫曼编码。 David Huffman,美国数学家，1952年发明了霍夫曼编码。霍夫曼树是他在编码中用到的特殊的二叉树。现在平时用到的压缩和解压技术
构造哈夫曼树代码实现（C++）
qq_46601680的博客
10-26 2798
哈夫曼树又称作最优二叉树，是带权路径长度最小的二叉树。 一、算法步骤： 构造哈夫曼树算法的实现可以分成两大部分。 ①初始化:首先动态申请2n个单元;然后循环2n-1次，从1号单元开始，依次将1至m所有单元中的双亲、左孩子、右孩子的下标都初始化为0;最后再循环n次，输人前n个单中叶子结点的权值。 ②创建树:循环n-1次，通过n-1次的选择、删除与合并来创建哈夫曼树。选择是从当前森林中选择双亲为0且权值最小的两个树根结点s1和s2；删除是指将结点s1和s2的双亲改为非0；合并就是将s1和s2的权值和作为.
哈夫曼树(Huffman Tree,霍夫曼树,赫夫曼树)哈夫曼编码
weixin_38568503的博客
02-27 2028
霍夫曼编码,赫夫曼编码:
赫夫曼树 详细讲解
舒克日记的博客
05-17 3937
1、基本介绍 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree), 还有的书翻译为霍夫曼树。 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 2、赫夫曼树几个重要概念和举例说明 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1 结点的权及带权路径长
如何利用C语言实现霍夫曼译码
06-01
霍夫曼编码是一种变长编码，将频率高的字符用较短的编码表示，频率低的字符用较长的编码表示，从而达到压缩数据的效果。在解压数据时，需要对编码进行译码，还原原始数据。以下是利用C语言实现霍夫曼译码的基本步骤： 1. 定义霍夫曼树的数据结构。可以使用二叉树来实现霍夫曼树，每个节点包含一个字符和对应的编码。 2. 建立霍夫曼树。根据输入的霍夫曼编码表，可以构建出霍夫曼树。 3. 读取编码文件。从编码文件中读取霍夫曼编码字符串。 4. 译码。从根节点开始遍历霍夫曼树，根据读取的编码字符选择左子树或右子树，直到找到叶子节点，即为对应的字符。将译码出的字符输出到解码文件中。 下面是一个简单的霍夫曼译码的C语言实现示例： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Node { char ch; struct Node* left; struct Node* right; } Node; Node* buildHuffmanTree(char** codeTable, char* chars, int* freq, int size) { Node* nodes[size]; for (int i = 0; i < size; ++i) { nodes[i] = (Node*) malloc(sizeof(Node)); nodes[i]->ch = chars[i]; nodes[i]->left = NULL; nodes[i]->right = NULL; } while (size > 1) { int i, j; if (freq[0] < freq[1]) { i = 0; j = 1; } else { i = 1; j = 0; } for (int k = 2; k < size; ++k) { if (freq[k] < freq[j]) { j = k; if (freq[j] < freq[i]) { int temp = i; i = j; j = temp; } } } Node* left = nodes[i]; Node* right = nodes[j]; Node* parent = (Node*) malloc(sizeof(Node)); parent->ch = '\0'; parent->left = left; parent->right = right; freq[j] = freq[i] + freq[j]; freq[i] = freq[size - 1]; nodes[i] = parent; nodes[j] = nodes[size - 1]; size--; } return nodes[0]; } int decodeHuffman(char* code, int length, Node* root, char* output) { int index = 0; Node* current = root; for (int i = 0; i < length; ++i) { if (code[i] == '0') { current = current->left; } else { current = current->right; } if (current->left == NULL && current->right == NULL) { output[index++] = current->ch; current = root; } } output[index] = '\0'; return index; } int main() { char* codeTable[5] = {"10", "11", "00", "010", "011"}; char chars[5] = {'a', 'b', 'c', 'd', 'e'}; int freq[5] = {10, 20, 30, 15, 25}; Node* root = buildHuffmanTree(codeTable, chars, freq, 5); char* code = "100111001011000101010110"; char output[100]; int length = strlen(code); int size = decodeHuffman(code, length, root, output); printf("Decoded string: %s\n", output); return 0; } ``` 这个示例实现了一个简单的霍夫曼译码，输入的编码字符串为"100111001011000101010110"，输出的解码字符串为"cbade"。需要注意的是，这个示例只是为了演示霍夫曼译码的基本思路，实际应用中需要根据具体需求进行修改和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值