C代码小包

已于 2022-02-05 16:14:31 修改
阅读量1k 收藏 5
点赞数 3
分类专栏： C语言 文章标签： c语言 霍夫曼树 数据结构
于 2022-02-05 15:51:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54036055/article/details/122790830
版权

哈夫曼编码 哈夫曼树 数据压缩 C语言 文件操作
关键词由CSDN通过智能技术生成

哈夫曼编码/译码器整套代码（历史博客 有详细解读）：

 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define Max 100                     //最大叶子结点个数

//定义哈夫曼树的结点
typedef struct {
	char data;     //数据域
	float weight;    //权值域
	int parent;    //双亲域
	int LChild;    //左孩子域
	int RChild;    //右孩子域
}Huffnode;
Huffnode* ht;

//定义编码的结点
typedef struct {
	char cd[Max];                //cd[]存放哈夫曼编码
	int start;
}Huffcode;
Huffcode* hc;

//菜单
void Menu()
{
	printf("*****************************************\n");
	printf("*                                       *\n");
	printf("*          哈夫曼编/译码系统            *\n");
	printf("*                                       *\n");
	printf("*****************************************\n");
	printf("*            1.调用已初始化的           *\n");
	printf("*            2.手动初始化               *\n");
	printf("*            E(e).编码                  *\n");
	printf("*            D(d).译码                  *\n");
	printf("*            P(p).打印代码文件          *\n");
	printf("*            T(t).打印哈夫曼树          *\n");
	printf("*            Q(q).退出                  *\n");
	printf("*****************************************\n");
	printf("请键入操作：");
}

//输入结点信息
void Input() {
	void Hfmtree(Huffnode * ht);
	void Huffcoding(Huffnode * ht);
	FILE* fp;
	int i, n;

	printf("enter elem number:");
	scanf_s("%d", &n);
	ht = (Huffnode*)malloc((2 * n) * sizeof(Huffnode));
	if (ht == NULL) {
		printf("wrong!");
		exit(0);
	}
	ht[0].weight = n;
	for (i = 1; i <= n; i++) {
		char a = getchar();
		printf(" %d elem data and weight(中间用空格隔开):", i);
		scanf_s("%c%f", &ht[i].data, 1, &ht[i].weight);
	}
	Hfmtree(ht);
	Huffcoding(ht);
	if ((fp = fopen("D:\\hfm\\hfmtree.txt", "w")) == NULL) {
		printf("Open file hfmtree.txt error!\n");
		exit(0);
	}
	fputs("初始化如下：\n", fp);
	fprintf(fp, "%f\n", ht[0].weight);
	for (int i = 1; i <= ht[0].weight; i++)
		fprintf(fp, "%c%f\n", ht[i].data, ht[i].weight);
	fclose(fp);
	printf("\n\n\n初始化已完成，已存入hfmtree.txt文件中！\n");
}


//初始化带权结点
void Init() {
	void Hfmtree(Huffnode * ht);
	void Huffcoding(Huffnode * ht);
	FILE* fp;
	ht = (Huffnode*)malloc((2 * Max) * sizeof(Huffnode));
	if (ht == NULL) {
		printf("wrong!");
		exit(0);
	}
	ht[0].weight = 26;
	ht[1].data = 'A'; ht[1].weight = 64;
	ht[2].data = 'B'; ht[2].weight = 13;
	ht[3].data = 'C'; ht[3].weight = 22;
	ht[4].data = 'D'; ht[4].weight = 32;
	ht[5].data = 'E'; ht[5].weight = 103;
	ht[6].data = 'F'; ht[6].weight = 21;
	ht[7].data = 'G'; ht[7].weight = 15;
	ht[8].data = 'H'; ht[8].weight = 47;
	ht[9].data = 'I'; ht[9].weight = 57;
	ht[10].data = 'J'; ht[10].weight = 1;
	ht[11].data = 'K'; ht[11].weight = 5;
	ht[12].data = 'L'; ht[12].weight = 32;
	ht[13].data = 'M'; ht[13].weight = 20;
	ht[14].data = 'N'; ht[14].weight = 57;
	ht[15].data = 'O'; ht[15].weight = 63;
	ht[16].data = 'P'; ht[16].weight = 15;
	ht[17].data = 'Q'; ht[17].weight = 1;
	ht[18].data = 'R'; ht[18].weight = 48;
	ht[19].data = 'S'; ht[19].weight = 51;
	ht[20].data = 'T'; ht[20].weight = 80;
	ht[21].data = 'U'; ht[21].weight = 23;
	ht[22].data = 'V'; ht[22].weight = 8;
	ht[23].data = 'W'; ht[23].weight = 18;
	ht[24].data = 'X'; ht[24].weight = 1;
	ht[25].data = 'Y'; ht[25].weight = 16;
	ht[26].data = 'Z'; ht[26].weight = 1;
	Hfmtree(ht);
	Huffcoding(ht);
	if ((fp = fopen("D:\\hfm\\hfmtree.txt", "w")) == NULL) {
		printf("Open file hfmtree.txt error!\n");
		exit(0);
	}
	fputs("初始化如下：\n", fp);
	fprintf(fp, "%f\n", ht[0].weight);
	for (int i = 1; i <= ht[0].weight; i++)
		fprintf(fp, "%c%f\n", ht[i].data, ht[i].weight);
	fclose(fp);
	printf("\n\n\n初始化已完成，已存入hfmtree.txt文件中！\n");
}


//创建哈夫曼树
void Hfmtree(Huffnode* ht) {
	float n, m1, m2;
	int i, k, x1, x2;                    /*m1为最小权值，x1为其对应的下标；
										   m2为次小权值，x2为其对应的下标*/
	n = ht[0].weight;        /*ht[0].weight存放的是字符数*/
	for (i = 1; i <= 2 * n - 1; i++)
		ht[i].parent = ht[i].LChild = ht[i].RChild = 0;       /*对所有的ht[]的parent、LChile、RChild域进行初始化*/
	for (i = n + 1; i <= 2 * n - 1; i++) {          /*创建非叶结点，构建哈夫曼树*/
		m1 = m2 = 10000;     /*初始值赋的大一些*/
		x1 = x2 = 0;
		for (k = 1; k <= i - 1; k++)          /*k为可进行比较的结点的下标；
									  在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，其序号分别赋给x1、x2*/
			if (ht[k].parent == 0)
				if (ht[k].weight < m1) {
					m2 = m1;
					x2 = x1;
					m1 = ht[k].weight;
					x1 = k;
				}
				else if (m1 < ht[k].weight < m2) {
					m2 = ht[k].weight;
					x2 = k;
				}
		ht[i].weight = ht[x1].weight + ht[x2].weight;
		ht[x1].parent = i; ht[x2].parent = i;
		ht[i].LChild = x1; ht[i].RChild = x2;
	}
}

//创建哈夫曼编码
void Huffcoding(Huffnode* ht) {
	char d[Max];
	float n;
	int i, start, c, p;
	n = ht[0].weight;
	hc = (Huffcode*)malloc(Max * sizeof(Huffcode));          //分配当前编码的工作空间
	if (hc == NULL) {
		printf("wrong!\n");
		exit(0);
	}
	for (i = 1; i <= n; i++) {                                             //h[i]
		start = n;       //初始化编码起始指针
		c = i;               //从叶子结点开始向上倒推
		p = ht[i].parent;
		while (p != 0) {
			--start;                       //从右向左逐位存放编码,首先放结束符
			if (ht[p].LChild == c)
				d[start] = '0';
			else
				d[start] = '1';
			c = p;
			p = ht[p].parent;
		}
		hc[i].start = start;
		for (int k = start; k < n; k++) {
			hc[i].cd[k] = d[k];
		}
	}
}


//编码函数
void Encoding() {
	FILE* fp, * fp1;
	int i, m = 0;
	char a;
	char in[Max];
	char in1[Max];
	char out[Max * Max];
	if ((fp = fopen("D:\\hfm\\ToBeTran.txt", "a+")) == NULL) {
		printf("Open file ToBeTran.txt error!\n");
		exit(0);
	}
	if ((fp1 = fopen("D:\\hfm\\CodeFile.txt", "w")) == NULL) {
		printf("Open file ToBeTran.txt error!\n");
		exit(0);
	}

	//判断ToBeTran.txt是否为空
	if (fgetc(fp) == EOF) {
		printf("ToBeTran.txt文件为空\n请在相应位置打开文件输入\n\n");
		exit(0);
	}
	else {
		printf("成功读取ToBeTran.txt文件\n");
	}

	fseek(fp, 0L, SEEK_SET);         //定位到文件开始处
	fgets(in, Max, fp);
	int n = (int)strlen(in);
	for (i = 0; i < n; i++)
		for (int j = 1; j <= ht[0].weight; j++)
			if (in[i] == ht[j].data) {
				for (int k = hc[j].start; k < ht[0].weight; k++) {
					out[m++] = hc[j].cd[k];
				}
			}
	for (i = 0; i < m; i++)
		fprintf(fp1, "%c", out[i]);
	printf("\n\n\n编码结束，结果已存入CodeFile.txt文件中！\n");
	fclose(fp);
	fclose(fp1);
}


//译码函数
void Decoding() {
	FILE* fp, * fp1;
	int i, j, n, k, x, m, w;
	char out[Max];
	char in[Max * Max];
	if ((fp = fopen("D:\\hfm\\CodeFile.txt", "r")) == NULL) {
		printf("Open file CodeFile.txt error!\n");
		exit(0);
	}
	if ((fp1 = fopen("D:\\hfm\\TextFile.txt", "w")) == NULL) {
		printf("Open file TextFile.txt error!\n");
		exit(0);
	}
	fgets(in, Max * Max, fp);
	if ((int)strlen(in)) {
		printf("成功读取CodeFile.txt文件\n");
	}
	n = (int)strlen(in);
	i = 0; m = 0;
	while (i < n) {
		for (j = 1; j <= ht[0].weight; j++) {
			x = hc[j].start;
			for (k = x, w = i; k < ht[0].weight; k++, w++)
				if (in[w] != hc[j].cd[k])
					break;
			if (k >= ht[0].weight) {
				out[m++] = ht[j].data;
				break;
			}
		}
		i = w;
	}
	for (i = 0; i < m; i++)
		fprintf(fp1, "%c", out[i]);
	printf("\n\n\n译码结束，结果已存入TextFile.txt文件中！\n");
	fclose(fp);
	fclose(fp1);
}


//打印编码
void Print()
{
	FILE* fp, * fp1;
	int i = 0;
	int j = 0;
	char in[Max * Max];
	printf("代码文件为:\n");
	if ((fp = fopen("D:\\hfm\\CodeFile.txt", "r")) == NULL) {
		printf("Open file CodeFile.txt error!\n");
		exit(0);
	}
	if ((fp1 = fopen("D:\\hfm\\CodePrin.txt", "w")) == NULL) {
		printf("Open file CodePrin.txt error!\n");
		exit(0);
	}
	fgets(in, Max * Max, fp);
	int n = (int)strlen(in);
	for (; i < n; i++) {
		printf("%c", in[i]);
		fprintf(fp1, "%c", in[i]);
		j++;
	}
	printf("\n\n\n\n代码文件已存入CodePrin.txt文件中\n");
	fclose(fp);
	fclose(fp1);
}



//打印树
int DEPTH = 0;
void PreOrderTraverse(FILE* fp, int k) {
	int i;

	if (ht[k].RChild != 0) {
		DEPTH++;
		PreOrderTraverse(fp, ht[k].RChild);
		DEPTH--;
	}
	for (i = 0; i <= DEPTH; i++) {
		printf("    ");
		fprintf(fp, "        ");
	}
	printf("%f\n", ht[k].weight);
	fprintf(fp, "%f\n", ht[k].weight);

	if (ht[k].LChild != 0) {
		DEPTH++;
		PreOrderTraverse(fp, ht[k].LChild);
		DEPTH--;
	}

	if (ht[k].LChild == 0 && ht[k].RChild == 0)
		return;
	return;

}
void TreePrinting() {
	FILE* fp;
	if ((fp = fopen("D:\\hfm\\TreePrint.txt", "w")) == NULL) {
		printf("Open file TreePrint.txt error!\n");
		exit(0);
	}
	printf("哈夫曼树凹入表：\n");
	PreOrderTraverse(fp, ht[0].weight * 2 - 1);
	printf("\n\n\n\n凹入表已写入TreePrint.txt文件中\n");
	fclose(fp);
}

//释放空间
void Free() {
	free(ht);
	free(hc);
}


//主函数
int main() {
	char select;
	while (1) {
		Menu();
		scanf_s("%c", &select, 1);
		switch (select) {

		case '1':Init(); break;

		case '2':Input(); break;
		case 'e':
		case 'E':Encoding(); break;
		case 'd':
		case 'D':Decoding(); break;
		case 'p':
		case 'P':Print(); break;
		case 't':
		case 'T':TreePrinting(); break;
		case 'q':
		case 'Q':Free(); exit(1);
		default:printf("Input error!\n");
		}
		int x = getchar();
	}
}

@ooneo
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C程序代码
weixin_44749480的博客
10-18 2349
输入两个正整数m和n，求其最大公约数和最小公倍数。
数据结构与算法八——树
m0_53100741的博客
05-30 439
树的存储结构 树与二叉树的转换 树和森林的遍历 哈夫曼树 code 1：凹入表打印 #include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std; const int nmax=100; int f[nmax+1]; int s[nmax+1][nmax+1]; int tot; char a[nmax]; int GetDepth(int x){ if(!s[x][0
数据结构与算法（C语言版）---哈夫曼编译码器
stu_kk的博客
07-16 1万+
数据结构与算法（C语言）大作业------哈夫曼编译码器
C语言实现哈夫曼编码与译码
热门推荐
嵌入式与人工智能
11-28 3万+
在电报通讯中，电文是以二进制的0、1序列传送的。字符集中的字符的使用频率是不同的（比如e和t的使用较之q和z要频繁得多），哈夫曼编码可以使得编码的总长最短，从而相同的位长可以传送更多的信息。 本程序以下面的字符及使用频率为例： 字符 权值 a 0.12 b 0.40 c 0.15
哈夫曼树编码、译码---（c语言实现）
m0_74830524的博客
11-07 2658
涉及哈夫曼树的建树，编码、译码。实现的方式为用二维数组的方式加构成哈夫曼树.
C语言哈夫曼编/译码器（文件操作）
m0_53613854的博客
10-31 5496
这是一道数据结构的实验题。 实验三&四 哈夫曼编/译码器 一、实验目的 掌握哈夫曼编码基本运算以及存储结构表示。 二、实验内容： 1. 系统要求包含以下功能 1）初始化：从终端读入字符集大小n，以及n个字符和n个权值（或者读入字符集和频度数据文件），建立哈夫曼树，并将哈夫曼树存入到文件HfmTree中。 2）编码：利用已建好的哈夫曼树（如果不在内存中，则从文件中读入），从文件ToBeTran中读入原文，对原文进行编码，将编码后的结果存入文件CodeFile中。 3）译码：..
hping2 开源代码
08-01
8. **split.c**：可能涉及到数据包的分割处理，比如在发送大型数据包时，可能需要将其分割成多个小包进行传输。 9. **winscan.c**：从名字上看，这可能是针对Windows系统的扫描功能，可能是为了扫描网络中的Windows...
编程资料chm文字资料小包
03-16
3. **函数**：在C++和C中，函数是代码组织的基本单元，可以复用并降低代码复杂性。函数定义了完成特定任务的一段代码，通过调用函数，可以在程序的不同位置重复执行这些任务，实现模块化编程。 4. **CHM文件的使用*...
c环境 实现tcp
05-15
在C环境中编写TCP客户端程序，需要了解基本的C语言语法，如变量定义、函数声明与调用、条件判断、循环等。 3. **Winsock库的使用**： Windows操作系统下，TCP编程通常依赖于Winsock库，它提供了与Berkeley套接字...
packetsquirrel-payloads:官方小包松鼠有效载荷存储库
05-26
这些有效载荷可能包括但不限于 Python 脚本、C 语言程序、配置文件或其他支持 Packet Squirrel 功能的代码。用户可以通过下载、定制和部署这些有效载荷，来扩展 Packet Squirrel 的功能，以适应特定的网络监控和安全...
按凹入表形式打印树形结构。
11-21
无按凹入表形式打印树形结构。（1）利用树的先根遍历方法； （2）利用结点的深度控制横向位置。
数据结构 哈夫曼树的建立和打印
04-05
哈夫曼树和哈夫曼图表的建立和输出 二叉树得打印
哈夫曼编码、解码、树的打印 C++
12-12
哈夫曼编码、解码、树的打印 C++ 完整的程序，包括头文件和源程序文件
哈夫曼树设计——利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通……
06-22
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码，请设计这样的一个简单编/译码系统。
tcp 粘包 拆包解决思路以代码
04-25
**TCP拆包**：与粘包相反，如果发送方发送的数据包大小小于接收缓冲区的大小，那么接收方可能会在一个接收操作中读取到多个数据包的组合，导致原本应该独立的多个小包被当作一个大包处理，这就是拆包。 为了解决TCP...
从键盘接收一串电文字符，输出对应的Huffman(哈夫曼)编码，同时，能翻译由Huffman编码生成的代码串，输出对应的电文字符串。
qq_64874743的博客
12-10 4383
要求 1.构造一棵Huffman树； 2.实现Huffman编码，并用Huffman编码生成的代码串进行译码 3.程序中字符串和权值是可变的，实现程序的灵活性。 算法分析 在电报通信中，电文是以二进制代码传送的。在发送时，需要将电文中的字符转换成二进制代码串，即编码；在接收时，要将收到的二进制代码转化为对应的字符序列，即译码。由于字符集中的字符被使用的频率是非均匀的，在传送电文时，要想使电文的总长尽可能短。因此，若对某字符集进行不等长的编码设计，则要求任意一个字...
Huffman编码与解码_C语言实现
刘东的博客
04-16 1万+
哈夫曼编码(Huffman Coding)，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。本次实验用C语言实现了Huffman编码器、Huffman解码器。
哈夫曼树的编码和解码
Lookdrama的博客
10-21 2523
哈夫曼树的编码和解码
c语言字符译码,数据结构C语言哈夫曼编码译码..doc
weixin_31445091的博客
05-17 276
数据结构C语言哈夫曼编码译码.题 目： 哈夫曼树编码译码院 系： 信息工程系专 业： 计算机科学与技术(网络方向)姓 名： 梁展荣学 号： 1151220115指导教师： 赵莹莹 刘欣日 期： 2013年7月3日桂林电子科技大学信息科技学院目 录一、设计思想11.1建立哈夫曼树的思想11.2建立哈夫曼编码表21.3对文件进行编...
tcp粘包c代码示例
最新发布
07-07
以下是一个简单的C语言代码片段，展示如何通过读取TCP套接字并处理数据段来避免粘包： ```c #include #include #include #include #include #define BUFFER_SIZE 1024 void process_data(char *data, int ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@ooneo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值