哈夫曼树建立、哈夫曼编码算法的实现

合集下载

哈夫曼编码的实现及应用

哈夫曼编码的实现及应用

哈夫曼编码的实现及应用哈夫曼编码(Huffman Coding)是一种用于数据压缩的编码技术,它可以将数据中频繁出现的字符或符号用较短的编码表示,从而减小数据的存储或传输开销。

以下是哈夫曼编码的实现和应用:实现哈夫曼编码:1. 构建哈夫曼树:首先,需要收集数据中不同字符或符号的频率信息,然后根据这些频率构建哈夫曼树。

在哈夫曼树中,频率较高的字符位于树的较低部分,频率较低的字符位于树的较高部分。

2. 分配编码:从根节点开始,沿着哈夫曼树的路径向下,为每个字符分配唯一的编码。

左子树通常表示0,右子树表示1。

这确保了编码是前缀编码,即没有一个编码是另一个编码的前缀。

3. 编码数据:使用分配的编码,将原始数据中的字符替换为相应的编码,从而生成压缩的数据。

哈夫曼编码的应用:1. 数据压缩:哈夫曼编码广泛用于数据压缩领域,包括压缩文件、图像、音频和视频数据。

由于频率较高的字符使用较短的编码,哈夫曼编码可以显著减小文件大小。

2. 通信系统:在通信系统中,数据通常需要在网络上传输。

使用哈夫曼编码可以减小数据传输的带宽要求,提高通信效率。

3. 文本编辑器:哈夫曼编码可用于实现字典压缩,减小文本文件的大小,使其更容易存储和传输。

4. 图像压缩:JPEG图片格式使用了哈夫曼编码来压缩图像数据,减小图像文件的大小。

5. 音频压缩:MP3音频格式中的音频数据也使用了哈夫曼编码,以减小音频文件的大小。

6. 存储设备:存储设备,如硬盘和闪存驱动器,通常使用哈夫曼编码来提高存储效率,减小数据的物理存储需求。

哈夫曼编码是一种有效的数据压缩方法,可以在多个领域中应用,以减小数据的大小并提高数据传输和存储的效率。

不同应用领域可能会采用不同的编码方式,但核心原理是一致的。

简述哈夫曼编码的过程

简述哈夫曼编码的过程

简述哈夫曼编码的过程哈夫曼编码是一种常见的压缩算法,通过对源数据进行编码,使得数据所占用的位数变得更小,从而达到压缩的目的。

它的原理是根据出现频率较高的字符使用较短的编码来代替,而出现频率较低的字符用较长的编码来代替。

哈夫曼编码实现的过程可以分为三个步骤:统计字符的频率、构建哈夫曼树、生成编码表。

下面我们分别来详细看一下各个步骤。

1. 统计字符的频率在实现哈夫曼编码前,需要先统计出每种字符在源数据中出现的次数。

假设源数据是一段文本,通过扫描文本并记录每个字符出现的次数,可以得到一个字符频率的统计表,一般用数组来存储。

2. 构建哈夫曼树在统计出每个字符的频率后,需要将其构建成一棵哈夫曼树。

哈夫曼树实质上是一种优先级队列,每个节点都有一个权重(频率),根据权重从小到大构建成树,树的叶子节点是每个字符,其它节点是合并后的节点,每个节点的权重是该子树所有节点的权重之和。

构建哈夫曼树的过程可以简单描述为:将每个字符看做一棵树,将权重最小的两个树合并成一个树,合并后的树的权重是它们两个权重之和,然后将这个新的树插入到队列中。

不断重复这个合并的过程,直到队列中只剩下一棵树为止。

3. 生成编码表生成编码表的过程就是将哈夫曼树转换为每个字符的哈夫曼编码。

哈夫曼编码的特点是任何一个字符的编码都不是另一个字符的前缀,即没有一个字符的编码是另一个字符编码的前缀,这就使得哈夫曼编码可以通过前缀的方式来压缩数据。

生成编码表的过程可以通过遍历哈夫曼树的叶子节点得到每个字符的编码。

至此,我们已经完成了哈夫曼编码的整个过程。

通过使用哈夫曼编码,可以将源数据压缩成更小的字节流,从而节省存储空间和传输数据的时间。

它广泛应用于数据压缩和加密解密等领域。

哈夫曼编码算法实现

哈夫曼编码算法实现

哈夫曼编码(Huffman Coding)是一种常见的数据压缩算法,它通过构建哈夫曼树(Huffman Tree)来实现。

以下是一个简单的哈夫曼编码算法的实现示例,使用Python 语言:pythonCopy codeimport heapqfrom collections import defaultdictclass HuffmanNode:def __init__(self, char, frequency):self.char = charself.frequency = frequencyself.left = Noneself.right = Nonedef __lt__(self, other):return self.frequency < other.frequencydef build_huffman_tree(data):frequency = defaultdict(int)for char in data:frequency[char] += 1priority_queue = [HuffmanNode(char, freq) for char, freq in frequency.items()]heapq.heapify(priority_queue)while len(priority_queue) > 1:node1 = heapq.heappop(priority_queue)node2 = heapq.heappop(priority_queue)merged_node = HuffmanNode(None, node1.frequency + node2.frequency)merged_node.left = node1merged_node.right = node2heapq.heappush(priority_queue, merged_node)return priority_queue[0]def build_huffman_codes(root, current_code="", codes={}):if root:if root.char is not None:codes[root.char] = current_codebuild_huffman_codes(root.left, current_code + "0", codes)build_huffman_codes(root.right, current_code + "1", codes)return codesdef huffman_encoding(data):if not data:return None, Noneroot = build_huffman_tree(data)codes = build_huffman_codes(root)encoded_data = "".join([codes[char] for char in data])return encoded_data, rootdef huffman_decoding(encoded_data, root):if not encoded_data or not root:return Nonecurrent_node = rootdecoded_data = ""for bit in encoded_data:if bit == "0":current_node = current_node.leftelse:current_node = current_node.rightif current_node.char is not None:decoded_data += current_node.charcurrent_node = rootreturn decoded_data# 示例data = "abracadabra"encoded_data, tree_root = huffman_encoding(data) decoded_data = huffman_decoding(encoded_data, tree_root)print("Original data:", data)print("Encoded data:", encoded_data)print("Decoded data:", decoded_data)。

哈夫曼编码原理及方法

哈夫曼编码原理及方法

哈夫曼编码原理及方法哈夫曼编码(Huffman Coding)是一种变长编码(Variable Length Code)的压缩算法。

它的原理是将频率较高的字符用较短的编码,频率较低的字符用较长的编码,以此降低数据的传输成本。

下面将详细介绍哈夫曼编码的原理及方法。

一、哈夫曼编码的原理哈夫曼编码的原理基于贪心算法(Greedy Algorithm),即对每个要编码的字符进行评估,按照字符在文本中出现的频率多少,将频率高的字符赋予较短的编码,频率低的字符赋予较长的编码。

这样在实际使用中,字符出现频率越高的编码长度越短,从而达到压缩数据的目的。

二、哈夫曼编码的方法1. 构建哈夫曼树(Huffman Tree)构建哈夫曼树的过程首先要确定每个字符在文本中出现的频率,然后将每个字符看作一个节点,并按照其频率大小建立一个小根堆(Min Heap)。

接下来,选取频率最小的两个节点,将它们合并到一起作为一个新的节点,并更新频率值,然后继续重复以上步骤,直到堆中只剩下一个节点,即为哈夫曼树的根节点。

2. 生成哈夫曼编码生成哈夫曼编码可以采用递归的方式,从根节点开始向左遍历时,将标记为 0,向右遍历时,将标记为 1,直到叶节点为止,然后向上回溯,将遍历的结果保存下来,得到该叶节点的哈夫曼编码。

遍历完所有的叶子节点后,即可得到所有字符的哈夫曼编码。

3. 压缩数据在使用哈夫曼编码进行数据压缩时,将字符替换为其对应的哈夫曼编码,这样可以将原始数据压缩为更小的数据量,达到压缩数据的目的。

在解压数据时,需要根据已生成的哈夫曼树,将压缩后的数据转换为原始数据,即将哈夫曼编码转换为对应的字符。

三、哈夫曼编码的优缺点哈夫曼编码的优点是具有压缩比高、压缩速度快、压缩后的数据无损还原等特点,可以广泛用于图像、音频、视频等多种数据类型的压缩。

同时,由于哈夫曼编码采用变长编码方式,所以可以使用相对较短的编码表示经常出现的字符,从而达到更好的压缩效果。

c++哈夫曼编码的实现

c++哈夫曼编码的实现

c++哈夫曼编码的实现=================哈夫曼编码是一种非常有效的数据压缩算法,它的主要思想是通过统计数据中各种符号的频率来构建一棵哈夫曼树,从而实现对原始数据的编码。

在C语言中,我们可以使用动态规划来实现哈夫曼编码。

一、哈夫曼编码的基本原理--------------哈夫曼编码是一种可变长度编码,其编码长度取决于原始数据中各个符号的频率。

频率越高的符号,其编码长度越短。

通过统计数据中各个符号的出现频率,我们可以构建出一棵哈夫曼树,这棵树中的每个节点都代表一个符号,节点的权值就是该符号的频率。

通过遍历哈夫曼树,我们可以得到每个符号的编码,从而实现数据的压缩。

二、C语言实现哈夫曼编码------------下面是一个简单的C语言程序,实现了哈夫曼编码的功能:```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define MAX_SYMBOL_COUNT 100 // 最大符号数量#define HUF_TREE_DEPTH 3 // 哈夫曼树深度为3typedef struct Node {char symbol; // 符号struct Node* left; // 左子节点struct Node* right; // 右子节点double frequency; // 频率} Node;// 创建新节点Node* createNode(char symbol, double frequency) {Node* node = (Node*)malloc(sizeof(Node));node->symbol = symbol;node->frequency = frequency;node->left = NULL;node->right = NULL;return node;}// 构建哈夫曼树Node* buildHuffmanTree(char* symbols, int symbolCount) { // 根据频率进行排序,从小到大排列double frequencies[MAX_SYMBOL_COUNT];for (int i = 0; i < symbolCount; i++) {frequencies[i] = symbols[i] == ' ' ? 0.0 : symbols[i] ? symbols[i] : -1; // 检查字符是否存在}qsort(frequencies, symbolCount, sizeof(double), compare); // 使用qsort进行排序Node* root = NULL; // 根节点为空,需要手动构建哈夫曼树int index = 0; // 下一个需要创建节点的索引(0到symbolCount-1之间)double currentFrequency = frequencies[index]; // 当前节点频率(如果不为空)while (index < symbolCount){ // 遍历所有符号和频率,直到遍历完为止if (root == NULL){ // 如果根节点为空,创建根节点并指向当前节点root = createNode(NULL, currentFrequency);} else{ // 如果根节点不为空,查找下一个需要创建节点的索引和当前节点频率是否小于当前节点频率的倒数index++; // 下一个需要创建节点的索引增加一个位置(包括当前节点)if (frequencies[index] / currentFrequency <1.0 / HUF_TREE_DEPTH) { // 如果满足条件,创建新的子节点并递归构建哈夫曼树(当前节点)Node* child = createNode(symbols[index], frequencies[index]); // 创建子节点并保存符号和频率信息if (root->left == NULL){ // 如果当前节点的左子节点为空,将当前节点设置为左子节点并递归构建哈夫曼树(左子树)root->left = child;} else{ // 如果当前节点的右子节点为空,将当前节点设置为右子节点并递归构建哈夫曼树(右子树)root->right = child;} // 更新根节点的左右子节点信息并递归构建哈夫曼树(父节点)} else{ // 如果当前节点不足以生成新的子节点(由于被优先排序)继续处理下一个节点 currentFrequency = frequencies[index]; // 将当前节点的频率设置为下一个需要创建节点的频率(避免重复处理同一个符号)} // 更新索引和当前频率信息(继续处理下一个符号)} // 结束while循环(处理完所有符号和频率)}。

哈夫曼编码算法实现完整版

哈夫曼编码算法实现完整版

哈夫曼编码算法实现完整版下面是哈夫曼编码算法的完整实现。

1.统计字符频率首先,我们需要统计待压缩的文本中每个字符出现的频率。

遍历文本文件,统计每个字符的出现次数。

将字符和对应的频率存储在一个频率表中。

2.构建哈夫曼树接下来,我们使用统计得到的频率表构建哈夫曼树。

哈夫曼树是一种二叉树,每个内部节点都有两个子节点,分别代表0和1首先,将频率表中的每个字符作为叶子节点,并按照频率从小到大进行排序。

然后,依次选择频率最小的两个节点,将它们作为子节点创建一个新的节点,并将新节点的频率设置为这两个节点频率之和。

将新节点插入到频率表中,然后删除原来的两个节点。

重复上述步骤,直到频率表中只剩下一个节点,即哈夫曼树的根节点。

3.生成编码表根据构建好的哈夫曼树,我们可以生成字符的编码表。

遍历哈夫曼树,记录从根节点到每个叶子节点的路径,其中0代表左子节点,1代表右子节点。

4.压缩数据通过编码表,我们可以将原始数据进行压缩。

遍历原始文本,将每个字符替换为对应的编码,然后将所有编码拼接成一个二进制字符串。

5.存储压缩后的数据将压缩后的二进制字符串进行存储,可以使用二进制文件或者文本文件存储。

6.解压数据对于解压,我们需要加载压缩后的数据,并重新构建哈夫曼树。

遍历压缩后的二进制字符串,根据哈夫曼树的结构逐个读取二进制位,当遇到叶子节点时,输出对应的字符。

通过上述步骤,我们可以实现对文本数据的压缩和解压。

需要注意的是,由于哈夫曼编码是基于字符频率进行优化的,所以对于不同的文本文件,编码效果也会有所不同。

较为重复的字符出现频率高的文本文件,哈夫曼编码效果会更好。

哈夫曼编码的实现

哈夫曼编码的实现

哈夫曼编码的实现哈夫曼树及哈夫曼编码哈夫曼树是判定过程最优的决策树,⼜称最优⼆叉树。

哈夫曼树的每个结点有权值,⼀个结点的权值实际上就是这个结点⼦树在整个树中所占的⽐例,通常指字符对应的⼆进制编码出现的概率。

权值⼤的结点距离根结点近。

树的带权路径长度(WPL):如果树中每个叶⼦上都带有⼀个权值,则把树中所有叶⼦的带权路径长度之和称为树的带权路径长度。

哈弗曼树就是带权路径长度最⼩的⼆叉树。

设某⼆叉树有n个带权值的叶⼦结点,则该⼆叉树的带权路径长度记为(Wk为第k个叶⼦结点的权值;Lk为该结点的路径长度):哈弗曼树是⾃底向上构建的,⼆叉树的左⼦树编码为0,右⼦树编码为1,然后从根到每个叶结点依次写出叶结点的编码,即哈夫曼编码。

哈夫曼编码是已知的最佳⽆损压缩算法,并且满⾜前缀码的性质,可以随时解码。

具体过程:给定字符集设为S={a,b,c,d,e,f,g,h},计算各个字符出现的概率,即权值。

将字符转换为树结点并根据权值⼤⼩将字符由⼩到⼤排序依次将权值最⼩的两个字符的权值相加,得到新的权值,为那两个字符的⽗结点,删除那两个字符,并将形成的树添加到排序列表中,⽗结点的权值按⼤⼩排序,在序列中找到合适的位置,然后再将最⼩的两个字符进⾏以上操作...最终只剩⼀个结点,并形成了⼀棵树,即哈弗曼树。

编码:在哈夫曼树中规定左分⽀表⽰符号0,右分⽀表⽰符号1。

对于每个叶⼦结点,从根结点到此叶⼦结点形成的编码就是这个结点表⽰字符的哈夫曼编码。

解码:译码过程是分解、识别各个字符,还原数据的过程。

从字符串头开始扫描到尾,依次去匹配。

图⽰过程⾸先是带权值的数第⼆步将最⼩的1和2组合相加形成⽗结点,并删除1和2依次进⾏这是只剩下⼀个结点,同时也形成了⼀棵树,这就是哈夫曼树。

代码实现⾸先构造结点类,每个结点需要有哈夫曼编码,字符本⾝,权值,以及左结点和右结点。

public class TreeNode {public String code = "";// 节点的哈夫曼编码public String data = "";// 节点的字符public int count;// 节点的权值public TreeNode lChild;//左结点public TreeNode rChild;//右结点public TreeNode(String data, int count) {this.data = data;this.count = count;}public TreeNode(int count, TreeNode lChild, TreeNode rChild) {this.count = count;this.lChild = lChild;this.rChild = rChild;}}计算每个字符的权重,flag⽤来判定取出的字符串是否存在,若不存在为true,如果存在那么就在出现次数统计上加⼀,即权重加⼀,如果没有出现过,就将它加⼊到存储字符的链表中。

实验六 Huffman编码算法实现

实验六   Huffman编码算法实现

实验六 Huffman编码算法实现---2011级通信一班尚青一、实验目的1、加深对压缩理论和技术的理解;2、增进对压缩编码算法的设计和编写能力;3、编写Vc++的Huffman编码;4、编写Matlab函数实现哈夫曼编码的算法。

(3或4选做一个即可)二、实验原理1、哈夫曼树的定义:假设有n个权值,试构造一颗有n个叶子节点的二叉树,每个叶子带权值为wi,其中树带权路径最小的二叉树成为哈夫曼树或者最优二叉树;2、哈夫曼树的构造:weight为输入的频率数组,把其中的值赋给依次建立的HT Node对象中的data属性,即每一个HT Node对应一个输入的频率。

然后根据data属性按从小到大顺序排序,每次从data取出两个最小和此次小的HT Node,将他们的data相加,构造出新的HTNode作为他们的父节点,指针parent,leftchild,rightchild赋相应值。

在把这个新的节点插入最小堆。

按此步骤可以构造构造出一棵哈夫曼树。

通过已经构造出的哈夫曼树,自底向上,由频率节点开始向上寻找parent,直到parent 为树的顶点为止。

这样,根据每次向上搜索后,原节点为父节点的左孩子还是右孩子,来记录1或0,这样,每个频率都会有一个01编码与之唯一对应,并且任何编码没有前部分是同其他完整编码一样的。

三、实验内容①初始化,统计文本文件中各字符的个数作为权值,生成哈夫曼树;②根据符号概率的大小按由大到小顺序对符号进行排序;③把概率最小的两个符号组成一个节点;④重复步骤(2)(3),直到概率和为1;⑤从根节点开始到相应于每个符号的“树叶”,概率大的标“0”,概率小的标“1”;⑥从根节点开始,对符号进行编码;⑦译码时流程逆向进行,从文件中读出哈夫曼树,并利用哈夫曼树将编码序列解码。

四、实验代码及结果function [h,l,hh,t]=huffman(p)%判断输入合不合法if (~isempty(find(p<0, 1)))error('Not a prob,negative component');endif (abs(sum(p)-1)>10e-10)error('Not a prob.vector,component do not add to 1')endn=length(p);q=p; %数组p附给qm=zeros(n-1,n); %创建(n-1)*n矩阵for i=1:n-1[q,l]=sort(q);%对概率数组q 进行从小至大的排序,并且用l 数组返回一个数组,该数组表示概率数组q 排序前的顺序编号m(i,:)=[l(1:n-i+1),zeros(1,i-1)];%由数组l 构建一个矩阵,该矩阵表明概率合并时的顺序,用于后面的编码q=[q(1)+q(2),q(3:n),1];%将排序后的概率数组q 的前两项,即概率最小的两个数加和,得到新的一组概率序列endfor i=1:n-1c(i,:)=blanks(n*n);%生成一个n-1 行n 列,并且每个元素的的长度为n 的空白数组,c 矩阵用于进行huffman 编码并且在编码中与 m矩阵有一定的对应关系endc(n-1,n)='0';%由于c矩阵的第n-1 行的前两个元素为进行huffman 编码加和运算时所得的最c(n-1,2*n)='1';%后两个概率,因此其值为0 或1,在编码时设第n-1 行的第一个空白字符为0,第二个空白字符1。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

#include <stdio.h>/*2009.10.25白鹿原*/
#include <stdlib.h>/*哈夫曼树建立、哈夫曼编码算法的实现*/
#include <string.h>
typedef char* HuffmanCode;/*动态分配数组,存储哈夫曼编码*/ typedef struct
{
unsigned int weight ; /* 用来存放各个结点的权值*/
unsigned int parent, LChild,RChild ; /*指向双亲、孩子结点的指针*/ }HTNode, * HuffmanTree; /*动态分配数组,存储哈夫曼树*/
void select(HuffmanTree *ht,int n, int *s1, int *s2)
{
int i;
int min;
for(i=1; i<=n; i++)
{
if((*ht)[i].parent == 0)
{
min = i;
i = n+1;
}
}
for(i=1; i<=n; i++)
{
if((*ht)[i].parent == 0)
{
if((*ht)[i].weight < (*ht)[min].weight)
min = i;
}
}
*s1 = min;
for(i=1; i<=n; i++)
{
if((*ht)[i].parent == 0 && i!=(*s1))
{
min = i;
i = n+1;
}
}
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 CrtHuffmanTree(HuffmanTree *ht , int *w, int n)
{ /* w存放已知的n个权值,构造哈夫曼树ht */
int m,i;
int s1,s2;
m=2*n-1;
*ht=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); /*0号单元未使用*/
for(i=1;i<=n;i++)
{/*1-n号放叶子结点,初始化*/
(*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;
} /*非叶子结点初始化*/
/* ------------初始化完毕!对应算法步骤1---------*/
for(i=n+1;i<=m;i++) /*创建非叶子结点,建哈夫曼树*/
{ /*在(*ht)[1]~(*ht)[i-1]的范围内选择两个parent为0且weight最小的结点,其序号分别赋值给s1、s2返回*/
select(ht,i-1,&s1,&s2);
(*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 outputHuffman(HuffmanTree HT, int m)
{
if(m!=0)
{
printf("%d ", HT[m].weight);
outputHuffman(HT,HT[m].LChild);
outputHuffman(HT,HT[m].RChild);
}
}
void CrtHuffmanCode(HuffmanTree *ht, HuffmanCode *hc, int n)
/*从叶子结点到根,逆向求每个叶子结点对应的哈夫曼编码*/
{
char *cd;
int i;
unsigned int c;
int start;
int p;
hc=(HuffmanCode *)malloc((n+1)*sizeof(char *)); /*分配n个编码的头指针*/ cd=(char * )malloc(n * sizeof(char )); /*分配求当前编码的工作空间*/
cd[n-1]='\0'; /*从右向左逐位存放编码,首先存放编码结束符*/
for(i=1;i<=n;i++) /*求n个叶子结点对应的哈夫曼编码*/
{
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*/
hc[i]=(char *)malloc((n-start)*sizeof(char)); /*为第i个编码分配空间*/
strcpy(hc[i],&cd[start]);
}
free(cd);
for(i=1;i<=n;i++)
printf("%d编码为%s\n",(*ht)[i].weight,hc[i]);
}
void main()
{
HuffmanTree HT;
HuffmanCode HC;
int *w;
int i,n; // the number of elements;
int wei; // the weight of a element;
int m;
printf("input the total number of the Huffman Tree:" );
scanf("%d",&n);
w=(int *)malloc((n+1)*sizeof(int));
for(i=1;i<=n;i++)
{
printf("input the %d element's weight:",i); fflush(stdin);
scanf("%d",&wei);
w[i]=wei;
}
CrtHuffmanTree(&HT,w,n);
m = 2*n-1;
outputHuffman(HT,m);
printf("\n");
CrtHuffmanCode(&HT,&HC,n);
}。

相关文档
最新文档