哈夫曼编/译码器

最新推荐文章于 2026-05-19 16:41:37 发布
原创 最新推荐文章于 2026-05-19 16:41:37 发布 · 1k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#霍夫曼树 #数据结构 #c语言
本文详细介绍了如何通过哈夫曼树实现文本字符的高效编码和解码，包括统计字符频度、建立哈夫曼树、编码正文、解码编码文件，适用于中文和英文文本。

哈夫曼编/译码器

  • 建立哈夫曼树：读入文件(*.source)，统计文件中字符出现的频度，并以这些字符的频度作为权值，建立哈夫曼树。
  • 编码：利用已建立好的哈夫曼树，获得各个字符的哈夫曼编码，并对正文进行编码，然后输出编码结果，并存入文件(*.code)中。
  • 译码：利用已建立好的哈夫曼树将文件(.code)中的代码进行译码，并输出译码结果，并存入文件(.decode)中。
  • 以下代码可以实现对大部分中文和英文的编码和译码

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 100
#define M 2 * N - 1


typedef struct
{
	char ch[3];      //字符
	int weight;     //权值
	int Parent, Lchild, Rchild;     //双亲，左孩子，右孩子
}HTNode, HuffmanTree[M + 1];    //哈夫曼树，0号不使用


typedef struct
{
	char ch[3];     //字符
	int WEI;     //权值
}weighting;     //权值


typedef struct    //堆串
{
	char* s;
	int len;
}HString;      //堆串


typedef char* HuffmanCode[N];


void read(FILE* fp, char str[]);         //读入文件
weighting* getweight(char str[], weighting w[]);     //计算权值
void Printvalue(weighting w[]);      //打印权值列表
void CrtHuffmanTree(HuffmanTree ht, weighting w[], int n);      //建立哈夫曼树
void select(HuffmanTree ht, int k, int* s1, int* s2);     //选择ht前i-1项中双亲为零且权值最小的两节点s1,s
void PrintTree(HuffmanTree ht, int n);     //打印哈夫曼树
void CrtHuffmanCode(HuffmanTree ht, HuffmanCode hc, int n);    //哈夫曼编码
void PrintCode(HuffmanCode hc, int n);     //打印哈夫曼编码
HString* Coding(char str[], weighting w[], HuffmanCode hc);     //编码并打印，并将编码保存至指定文件
void Decoding(char code[], HuffmanTree ht, int n);     //译码并保存至Decode.txt文件


int main()
{
	HuffmanTree H;
	HuffmanCode T;
	weighting WEI[10000];
	HString* STR;
	FILE* fp = NULL;
	char str[10000];
	char code[10000];
	weighting* W;
	printf("请输入获取电文的文件：");
	read(fp, str);
	W = getweight(str, WEI);     //计算权值
	int len = W[0].WEI;      //字符串数组长度
	CrtHuffmanTree(H, W, len);       //建立哈夫曼树
	CrtHuffmanCode(H, T, len);       //哈夫曼编码
	PrintCode(T, len);       //打印哈夫曼编码
	STR = Coding(str, W, T);     //编码并打印
	printf("请输入获取编码的文件：");
	read(fp, code);    //读入编码，将编码存入code
	Decoding(code, H, 2 * len - 1);     //译码
	return 0;
}


//读入文件
void read(FILE* fp, char str[])
{
	char filename[40];
	gets_s(filename);
	fp = fopen(filename, "r");
	if (fp == NULL)
	{
		printf("\nERROR!\n");
		exit(0);
	}
	int i = 0;
	char c;
	c = fgetc(fp);
	if (c == EOF)
	{
		printf("文件为空！！！");
		exit(0);
	}
	str[0] = c;
	i++;
	while (1)
	{
		c = fgetc(fp);
		if (feof(fp))
		{
			str[i] = '\0';
			break;
		}
		str[i] = c;
		i++;
	}
	//fscanf(fp, "%s", str);
	printf("文件中读出内容为：\n");
	puts(str);
	fclose(fp);
}


//构造哈夫曼树
void CrtHuffmanTree(HuffmanTree ht, weighting w[], int n)
{
	int m;
	m = 2 * n - 1;
	int i;
	//初始化哈夫曼树
	for (i = 1; i <= n; i++)
	{
		strcpy(ht[i].ch, w[i].ch);
		//ht[i].ch = w[i].ch;
		ht[i].weight = w[i].WEI;
		ht[i].Rchild = 0;
		ht[i].Lchild = 0;
		ht[i].Parent = 0;
	}
	for (i = n + 1; i <= m; i++)
	{
		ht[i].ch[0] = NULL;
		ht[i].weight = 0;
		ht[i].Rchild = 0;
		ht[i].Lchild = 0;
		ht[i].Parent = 0;
	}
	//给后面的结点赋值
	for (i = n + 1; i <= m; i++)
	{
		//选择树中双亲为0最小的两个值
		int s1, s2;
		select(ht, i - 1, &s1, &s2);
		ht[i].weight = ht[s1].weight + ht[s2].weight;
		ht[i].Lchild = s1;
		ht[i].Rchild = s2;
		ht[s1].Parent = i;
		ht[s2].Parent = i;
	}
	int len = w[0].WEI;
	PrintTree(ht, 2 * len - 1);
}


//选择ht前i-1项中双亲为零且权值最小的两节点s1,s2
void select(HuffmanTree ht, int k, int* s1, int* s2)
{
	int i;
	int j = 0;
	int min1 = 10000;
	int min2 = 10000;
	for (i = 1; i <= k; i++)
	{
		if (ht[i].weight <= min1 && ht[i].Parent == 0)
		{
			*s1 = i;
			j = i;
			min1 = ht[i].weight;
		}
	}
	for (i = 1; i <= k; i++)
	{
		if (i == j) continue;
		else
		{
			if (ht[i].weight <= min2 && ht[i].Parent == 0)
			{
				*s2 = i;
				min2 = ht[i].weight;
			}
		}

	}
}


//哈夫曼编码
void CrtHuffmanCode(HuffmanTree ht, HuffmanCode hc, int n)
{
	char* cd;
	int i;
	int c;
	int p;
	int start;
	cd = (char*)malloc(n * sizeof(char));      //临时编码数组
	cd[n - 1] = '\0';      //从叶子节点开始遍历到根，所以首先放置\0
	for (i = 1; i <= n; i++)      //求每个叶子结点的编码，共有n个叶子结点
	{
		start = n - 1;      //从后开始编写编码
		c = i;      //c为当前节点
		p = ht[i].Parent;     //p为其双亲
		while (p != 0)       //当其不为根节点时
		{
			start--;          //临时编码数组start指针向前挪动
			if (ht[p].Rchild == c)
			{
				cd[start] = '1';
			}
			else
			{
				cd[start] = '0';
			}
			c = p;
			p = ht[p].Parent;
		}
		hc[i] = (char*)malloc((n - start) * sizeof(char));
		strcpy(hc[i], &cd[start]);
	}
	free(cd);
}


//打印哈夫曼树
void PrintTree(HuffmanTree ht, int n)
{
	int i;
	printf("\nPrinthuffmantree:\n");
	printf("字符\tweight\tParent\tLchild\tRchild\n");
	for (i = 1; i <= n; i++)
	{
		if (ht[i].ch[0] == '\n')
			printf("\\n\t%d\t%d\t%d\t%d\n", ht[i].weight, ht[i].Parent, ht[i].Lchild, ht[i].Rchild);
		else if (ht[i].ch[0] == NULL)
			printf("NULL\t%d\t%d\t%d\t%d\n", ht[i].weight, ht[i].Parent, ht[i].Lchild, ht[i].Rchild);
		else if (ht[i].ch[0] == ' ')
			printf("' '\t%d\t%d\t%d\t%d\n", ht[i].weight, ht[i].Parent, ht[i].Lchild, ht[i].Rchild);
		else if (ht[i].ch[2] == '\0')           //判断是否为汉字
			printf("%s\t%d\t%d\t%d\t%d\n", ht[i].ch, ht[i].weight, ht[i].Parent, ht[i].Lchild, ht[i].Rchild);
		else
			printf("%c\t%d\t%d\t%d\t%d\n", ht[i].ch[0], ht[i].weight, ht[i].Parent, ht[i].Lchild, ht[i].Rchild);
	}
	printf("\n\n");
}


//打印哈夫曼编码
void PrintCode(HuffmanCode hc, int n)
{
	int i;
	printf("\nPrintcode:\n");
	for (i = 1; i <= n; i++)
	{
		puts(hc[i]);
	}
	printf("\n\n");
}


//计算权值
weighting* getweight(char str[], weighting* w)
{
	int i = 0;
	int j = 0;
	int k;
	int m;
	char s[3];
	int len = strlen(str);      //字符串长度
	for (i = 0, k = 1; i < len; i++, k++)     //遍历字符串,将每一个字符记录下来，并赋初值为1
	{
		if ((str[i] < 65 || (str[i] > 90 && str[i] < 97) || str[i] > 122) && str[i] != ' ' && str[i] != '\n' && str[i] != '\0')      //如果是汉字
		{
			s[0] = str[i];           //依次存入字符串
			s[1] = str[i + 1];
			s[2] = '\0';
			i++;
			strcpy(w[k].ch, s);         //拷贝当前字符串到权值列表的字符位置
			w[k].WEI = 1;
		}
		else                   //如果不是汉字
		{
			w[k].ch[0] = str[i];        //只接受一个字节放入w[k].ch[0]的位置
			w[k].WEI = 1;
		}
	}
	char str1[3];
	int chinese = 0;     //记录汉字的个数
	for (i = 0, k = 1; i < len; i++, k++)
	{
		if ((str[i] < 65 || (str[i] > 90 && str[i] < 97) || str[i] > 122) && str[i] != ' ' && str[i] != '\n' && str[i] != '\0')     //如果是汉字
		{
			str1[0] = str[i];
			str1[1] = str[i + 1];
			str1[2] = '\0';
			strcpy(w[k].ch, str1);
			i++;
			chinese++;     //记录中文的个数
		}
		else
		{
			w[k].ch[0] = str[i];
		}
		for (j = i + 1; j <= len; j++)
		{
			if ((str[j] < 65 || (str[j] > 90 && str[j] < 97) || str[j] > 122) && str[j] != ' ' && str[j] != '\n' && str[j] != '\0')
			{
				s[0] = str[j];
				s[1] = str[j + 1];
				s[2] = '\0';
				j++;                 //j向后移动一个字节，移到汉字的下一个字节
				if (strcmp(str1, s) == 0)
				{
					w[k].WEI++;
				}
			}
			else       // 不是汉字的话，直接比较
			{
				if (str[i] == str[j])        
				{
					w[k].WEI++;
				}
			}
		}
	}
	for (i = 1; i <= k; i++)     //遍历数组，去重
	{
		for (j = i + 1; j <= k; j++)
		{
			if (w[i].ch[2] == '\0')          //之前存储汉字的时候将字符串最后一个字节为'\0'，所以判断最后一个字节是否为'\0'，就可以知道当前字符是否为汉字，然后确定比较方式
			{
				if (strcmp(w[i].ch, w[j].ch) == 0)
				{
					w[j].WEI = 0;
				}

			}
			else
			{
				if (w[i].ch[0] == w[j].ch[0])
				{
					w[j].WEI = 0;
				}
			}
		}
	}
	k = 1;
	weighting wnew[10000];      //建立一个新的权值列表
	for (i = 1; i <= len - chinese; i++)       //长度为原本字符串的长度减去汉字的个数
	{
		if (w[i].WEI == 0)  continue;           //将重复字符的跳过
		else
		{
			wnew[k] = w[i];
			k++;
		}
	}
	wnew[0].WEI = k - 1;                 //权值列表的第0位的WEI值为该权值列表的长度
	w = wnew;
	Printvalue(w);
	return &w[0];
}


//打印权值列表
void Printvalue(weighting w[])
{
	int i;
	int len = w[0].WEI;
	printf("\nPrintvalue:\n");
	printf("字符\tweight\n");
	for (i = 1; i <= len; i++)
	{
		if (w[i].ch[0] == '\n')
			printf("\\n\t%d\n", w[i].WEI);
		else if (w[i].ch[0] == ' ')
			printf("' '\t%d\n", w[i].WEI);
		else
		{
			if (w[i].ch[2] == '\0')               //判断是否为汉字
			{
				printf("%s\t%d\n", w[i].ch, w[i].WEI);
			}
			else
			{
				printf("%c\t%d\n", w[i].ch[0], w[i].WEI);
			}
		}
	}
	printf("\n\n");
}


//编码并打印
HString* Coding(char str[], weighting w[], HuffmanCode hc)   //字符串、权值列表、哈夫曼编码
{
	HString HS[1000];    //堆串
	HS->len = 0;
	int i;
	FILE* fp;
	char filename[40];
	int len = strlen(str);
	int length = w[0].WEI;
	int j;
	char s[3];
	int k = 0;
	char ch;
	int flag;
	for (i = 0; i < len; i++)     //遍历字符串
	{
		if ((str[i] < 65 || (str[i] > 90 && str[i] < 97) || str[i] > 122) && str[i] != ' ' && str[i] != '\n' && str[i] != '\0')
		{
			s[0] = str[i];
			s[1] = str[i + 1];
			s[2] = '\0';
			i++;
			flag = 1;
		}
		else
		{
			flag = 0;
		}
		for (j = 1; j <= length; j++)
		{
			if (strcmp(s, w[j].ch) == 0 && flag == 1)
			{
				HS[k].s = hc[j];
				k++;
				HS->len++;
				break;
			}
			if (w[j].ch[0] == str[i] && flag == 0)
			{
				HS[k].s = hc[j];
				k++;
				HS->len++;
				break;
			}

		}
	}
	printf("编码结果：");
	for (i = 0; i < HS->len; i++)
	{
		//puts(HS[i].s);
		printf("%s", HS[i].s);
	}
	printf("\n");
	printf("请输入要保存编码的文件：");
	gets_s(filename);
	printf("\n");
	fp = fopen(filename, "w");
	if (fp == NULL)
	{
		printf("\nERROR!\n");
		exit(0);
	}
	for (i = 0; i < HS->len; i++)
	{
		fprintf(fp,"%s",HS[i].s);
	}
	fclose(fp);
	return HS;
}



//译码并保存至Decode.txt文件
void Decoding(char code[], HuffmanTree ht, int n)
{
	printf("译码结果将保存至Decode.txt文件\n");
	FILE* fp;
	fp = fopen("Decode.txt", "w");      //打开Decode.txt文件
	int i;
	int j;
	int start = n;
	int len = strlen(code);
	for (i = 0; i < len; i++)
	{
		if (code[i] == '1')
		{
			for (j = start; j > 0; j++)     //从哈夫曼树的最底下开始遍历
			{
				if (ht[j].Rchild != 0)
				{
					start = ht[j].Rchild;
					break;
				}
			}
			if (ht[start].Lchild == 0)
			{
				if (ht[start].ch[2] == '\0')
				{
					printf("%s", ht[start].ch);
					fprintf(fp, "%s", ht[start].ch);
					start = n;
				}
				else
				{
					printf("%c", ht[start].ch[0]);
					fprintf(fp, "%c", ht[start].ch[0]);
					start = n;
				}
			}
		}
		if (code[i] == '0')
		{
			for (j = start; j > 0; j++)     //从哈夫曼树的最底下开始遍历
			{
				if (ht[j].Lchild != 0)
				{
					start = ht[j].Lchild;
					break;
				}
			}
			if (ht[start].Lchild == 0)
			{
				if (ht[start].ch[2] == '\0')
				{
					printf("%s", ht[start].ch);
					fprintf(fp, "%s", ht[start].ch);
					start = n;
				}
				else
				{
					printf("%c", ht[start].ch[0]);
					fprintf(fp, "%c", ht[start].ch[0]);
					start = n;
				}
			}
		}
	}
	fclose(fp);
}
41%加1
关注
赫哈曼编码的应用对输入的一串字符实现赫夫曼编码，再对赫夫曼编码生成的代码串进行译码，输出电文字符串
03-24
本设计要求是对输入的一串字符实现赫夫曼编码，再对赫夫曼编码生成的代码串进行译码，输出电文字符串。赫夫曼编码是一种将信息转换成二进制编码有效的方法之一，赫夫曼编码是利用赫夫曼树求得的用于通信的二进制编码。而这次我们的课程设计对编码译码的要求不是太高，只是将大写字母或小写字母转化成二进制编码，或将二进编码转化成大写字母或小写字母，虽然功能有一点局限，但也是一次成功的尝试，能满足一般的需求
怎么实现huffman（哈夫曼编码）以及解码
weixin_34405354的博客
11-12 1836
 一、编码 【题目描述】 给定一篇用于通信的英文电文，统计该电文中每个字符出现的频率，按频率左小右大的方法为这些字符建立哈夫曼(Huffamn)树，并编出每个字符的哈夫曼树码，输出该电文的哈夫曼码译文。   【输入】 输入文件huffman.in是一篇用于通信的英文电文。 【输出】 输出文件huffman.out输出该电文的哈夫曼码译文。   【输入输出样例1】 ...
C语言实现哈夫曼编码与译码
热门推荐
嵌入式与人工智能
11-28 3万+
在电报通讯中，电文是以二进制的0、1序列传送的。字符集中的字符的使用频率是不同的（比如e和t的使用较之q和z要频繁得多），哈夫曼编码可以使得编码的总长最短，从而相同的位长可以传送更多的信息。 本程序以下面的字符及使用频率为例： 字符 权值 a 0.12 b 0.40 c 0.15
RT-Thread实战：基于STM32F103的线程创建与LED控制
最新发布
weixin_30572613的博客
05-19 619
实时操作系统（RTOS）是现代嵌入式开发的核心技术，它通过任务调度和资源管理，实现了多任务的并发执行。其基本原理是基于优先级抢占或时间片轮转的调度算法，确保关键任务能够及时响应。在嵌入式领域，RTOS的技术价值在于提升系统的可靠性、实时性和资源利用率，尤其适用于物联网设备、工业控制等复杂场景。以STM32微控制器为例，开发者常面临从裸机编程转向RTOS的挑战，其中线程创建、任务调度和系统初始化是关键步骤。本文聚焦于RT-Thread操作系统，结合Keil MDK开发环境，详细讲解如何通过RTE配置系统内核、
c语言解决哈夫曼编码问题
m0_73730740的博客
03-22 775
用c语言实现哈夫曼编码的问题
基于哈夫曼树的编码和译码
apandar的博客
12-09 5346
1.实验要求： 利用哈夫曼编码:要传输一些数据(比如英文单词), 设计一个利用哈夫曼算法的编码系统, 为这些单词编码, 并在接收端进行译码. 基本要求: (1).将需要传输的数据存放在数据文件data.txt 中. (2).读入数据文件并为其编码, 将编码后的内容存入文件code.txt中. (3).读入code.txt, 译码, 并将译码后的内容输出在屏幕上. 2.基本思路： (1).编码: 统...
哈夫曼编/译码系统的设计与实现
浅笑醉红楼
03-15 2843
【实验目的】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。 【实验要求】 （1）从数据文件DataFile.dat中读入字符及每个字符的权值，建立哈夫曼树HuffTree； （2）编码（EnCoding）。用已建好的哈夫曼树，对文件ToBeTran.dat中的文
Ｃ＋＋实现哈夫曼编 / 译码器
qq_42096498的博客
06-21 2840
问题描述        利用哈夫曼编码进行信息通信可以较大提高信息利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待数据预先编码留在接收端将传来的数据进行译码。对于双工通道（即可以双向传输信息的通道），每端都需要一个完整的编 / 译码系统。试为这样的信息收发站写一个哈夫曼码的编译码系统。该系统应具有...
C/C++哈夫曼编/译码器[2025-06-16]
code helper
06-16 712
本文介绍了一个基于C/C++实现的哈夫曼编/译码系统。系统具备初始化、编码、译码、打印代码文件和哈夫曼树等功能，使用字符频度表构建哈夫曼树，实现了对文本"THIS PROGRAM IS MY FAVORITE"的编码和解码。系统采用菜单交互方式，支持文件操作和二进制编码存储，实际测试中实现了约2:1的压缩比。文章详细展示了各功能模块的运行效果，包括字符编码输出、哈夫曼树可视化、文件压缩解压等过程，并提供了源码获取途径。该系统有效验证了哈夫曼编码在数据压缩领域的实用价值。
数据结构课程设计———迷宫和哈夫曼编/译码器
冰炭不投day的博客
05-22 4562
数据结构课程设计———迷宫和哈夫曼编/译码器 一 .目录 数据结构课程设计———迷宫和哈夫曼编/译码器 一 .目录 二 . 迷宫 1. 问题描述 2. 题目要求 3. 思路 4. 运行结果 三. 哈夫曼编/译码器 1. 问题描述 2. 题目要求 3. 思路 4. 运行结果 三.源码地址 二 . 迷宫 1. 问题描述 迷宫是实验心理学中一个古典问题。用计算...
【数据结构】哈夫曼编/译码器
2301_80059009的博客
12-27 506
唯一需要注意的地方就是得提前在ToBeTran文件中写好要编码的东西，且在输入字符时要把文件里面需要编码的字符全输进去，不然编不了。毕竟字符都不存在，谈何编码？另外，此代码只使用于较短内容的编译码，要想实现长篇文章的编译码，得需读者自行研究了。（记得提前将空格存入编码里，这样编译码出来的东西才会有空格）
【信源编码技术】实验二：Huffman编码实验
qq_46643786的博客
11-18 562
实验目的 1.利用程序huffenc和huffdec进行以下操作(在每种情况下，利用由被压缩图像生成的码本) (a)对Sena、Sensin和Omaha图像进行编码。 (b)编写一段程序，得到相邻像素之差，然后利用huffman对差值图像进行编码 给出以上每一试验得出的文件大小，并解释其差别。 2.利用程序huffenc和huffdec，并使用由Sensin图像生成的码本，对Bookshelf1和Sena图像进行编码。将这一结果与使用被压缩图像生成码本的情况进行对比。 实验过程 1（a）利用源图像生成的码本
哈夫曼编码
NBA_1的博客
05-15 4015
目录 一、哈夫曼编码的由来 二、构造哈夫曼编码的方法 三、哈夫曼编码的构造实例 四、哈夫曼编码的性质 五、哈夫曼编码的算法实现 六、哈夫曼编码的应用举例——文件的编码和解码 一、哈夫曼编码的由来 1、在远程通讯中，要将待传字符转换成由二进制的字符串如下图所示: 如上图所示若将每个字符都用同样位数的二进制数来表示的话会产生浪费。但如果将编码设计为长度不等的二进制编码，即让待传字符串中出现次数较多的字符采用尽可能短的编码，则转换的二进制字符串便可能减少。如下图所示： 而哈夫曼编码刚好满足前缀编码的要求，并却
哈夫曼1-用哈夫曼编码与哈夫曼树完成对字符串的编码及解码
weixin_43541094的博客
07-16 5330
哈夫曼树是二叉树的一种特别应用，哈夫曼树仍然是一颗二叉树，只是其满足一定条件（带权最短路径二叉树） 这里先尝试实现取出一个由英文字母组成的字符串中每个出现的字母及其出现的次数 需求分析：1，从键盘输入一个字符串 2，对该字符串中出现的字符进行频度统计 3，根据频度统计，完成哈夫曼树 4，根据哈夫曼树得到每一个字符的哈夫曼编码 5，将原字符串中的每一个字符，与其相对应的哈夫曼编码代替，得到结果 6，将结果还原成原字符串 这里先实现最简单的求字符串中每个字符的频度 这样就完成了对字符串中字符的出现频率分
c语言实现哈夫曼编/译码器
清晨的炸鸡啤酒花生米的博客
06-20 8669
c语言实现哈夫曼编译码器 分析设计如下功能的哈夫曼编译码系统： 初始化：从终端读入字符集大小为n,以及n个字符和n个权值，建立哈夫曼树。 编码：利用已建好的哈夫曼树，通过计算权重值计算输出对应字符集的哈夫曼编码。 译码：利用已建立好的哈夫曼树，将用户输入电文中的代码进行译码，译码结果进行输出。 已经完美运行，话不多说先上代码！（建议保存为cpp运行） 代码 #include<stdio.h>//建议保存为cpp运行 #define maxleaf 20//最大叶子数目 #defi
哈夫曼树的编码与译码
weixin_44214091的博客
01-31 2502
要求： 对输入的一串电文字符实现哈夫曼编码，并对给定的代码串进行译码，输出电文字符串。具体包括哈夫曼树的建立、哈夫曼编码的生成和编码文件的译码。 假设举如下例子 存储结构： 模型： 哈夫曼树节点类： package keshe; public class HuffNode { Character ch;//字符 int val;//判断值，往左走即置为0，往右走即置为1 i...
Huffman编码与解码
的博客
03-18 1万+
使用C++、和Java分别实现构造哈夫曼树
（数据结构） 哈夫曼树的编码和解码简单的实现
weixin_45944348的博客
07-04 3112
输入一段英文原文，构造哈夫曼树，生成对应的编码表，输出原文对应的编码，或者是根据已经生成的编码表，输入一段二进制数编码，得到对应的字符原文。 #include<stdio.h> #include<iostream> #include<conio.h> #include<string.h> #include<stdlib.h> using namespace std; //哈夫曼树的存储表示 typedef struct{ int weight
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值