数据结构我好爱：09 Huffman树（无理论版）

最新推荐文章于 2023-03-28 23:05:32 发布
最新推荐文章于 2023-03-28 23:05:32 发布
阅读量209 收藏
点赞数 4
分类专栏： 笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60678811/article/details/124995133
版权

现在默认你已经明白了Huffman树的原理！（问就是理论我也不会！）

通过我片面操作的有了片面的结论：

   在Huffman应用与字符压缩的时候，虽然原理是树，但是确实主要的就表，有好几种记录表来记录信息：孩子双亲以及权重的记录，单个字符对应编码串的记录等

各种结构体：

        1.单个node存储字符与出现次数

        2.根据ASII码，字符共128种且有部分无法打印显示

                创建List记录表

        3.创建孩子双亲记录表：

        4.字符编码记录表：通过char就可以确定它的编码串

typedef struct {
	char ch;
	int count;
}node;

typedef struct {
	node data[catage];//128种
	int length;
}List,*ListPtr;

typedef struct {
	int parent;
	int lchild;
	int rchild;
	int weight;
	char data;
}record_map,*record_mapPtr;//记录表

typedef struct {//unoder_map <char,int>
	char data;
	char* str;
}code_graph, * code_graphPtr;//编码表

初始化：

        1.List记录表的初始化，length是为了记录有多少种不同的字符串（与后文cat:category相同）；

        2.创建字符编码记录表

ListPtr Init() {
	ListPtr list = (ListPtr)malloc(sizeof(List));
	list->length = 0;
	return list;
}

//----------------------------------------------

code_graphPtr Init_graph(int len) {
	code_graphPtr graph = (code_graphPtr)malloc(sizeof(code_graph)*len);

	for (int i = 0; i < len; i++) {
		graph[i].str = (char*)malloc(sizeof(char) * len);
	}
	return graph;
}

读取文件：

        fgets 读取一行(.txt的一行可以 “ 无限长 ”）读取到source数组；

void Read(char* source) {
	FILE* fp = fopen("D:\\D_desktop\\input.txt", "r+");
	if (fp == NULL) return;
	else {
		fgets(source, Max, fp);
	}
	fclose(fp);
}

字符计数：（靠字符串与整数的变换）

        ASII数组，字符的编码小于128；

        memset ASII数组全置为0；

        ASII [i] 的值表示字符 i 的出现次数

        ASII数组非0的数据都交给List记录表吧！

void CharCount(ListPtr list, char* source) {
	int ASII[catage];
	memset(ASII, 0, sizeof(int) * catage);
	for (int i = 0; i < strlen(source); i++) {
		ASII[(int)source[i]]++;
		//printf("%c --%d \n", source[i],ASII[source[i]]);
	}
	for (int i = 0; i < catage; i++) {
		if (ASII[i] != 0) {
			//printf("%c --%d \n", i, ASII[i]);
			list->data[list->length].ch = (char)i;//???
			list->data[list->length].count = ASII[i];
			list->length++;
		}
	}
}

选择两个较小权值：每次选取前 len 个当中的两个权重较小值

        _CRT_INT_MAX; 是vs自带定义的宏

void select(int len, int* tow_ints, record_mapPtr root) {
	int min = _CRT_INT_MAX;
	for (int i = 1; i <= len; i++) {
		if (root[i].weight < min && root[i].parent==0) {
			tow_ints[0] = i;
			min = root[i].weight;
		}
	}
	min = _CRT_INT_MAX;
	for (int i = 1; i <= len; i++) {
		if (root[i].weight < min && i != tow_ints[0] && root[i].parent == 0) {
			tow_ints[1] = i;
			min = root[i].weight;
		}
	}
}

创建孩子双亲权重记录表：

        二叉树有一种数组表示方法：创建孩子双亲权重记录表的过程其实就是创建了一颗树；

record_mapPtr creatHuff(ListPtr list) {
	record_mapPtr root = (record_mapPtr)malloc(sizeof(record_map) * ((list->length) * 2 + 1));
	int total = 2 * list->length - 1;
	for (int i = 0; i <= list->length; i++) {
		root[i].parent = 0;
		root[i].lchild = 0;
		root[i].rchild = 0;
		root[list->length + i].parent = 0;
		root[list->length + i].lchild = 0;
		root[list->length + i].rchild = 0;

		root[i+1].weight = list->data[i].count;
		root[i+1].data = list->data[i].ch;
		//printf("%c ", list->data[i].ch);
	}
	int min[2];
	for (int i = list->length + 1; i <= total; i++) {
		select(i - 1, min, root);
		root[i].lchild = min[0];
		root[i].rchild = min[1];
		root[i].weight = root[min[0]].weight + root[min[1]].weight;
		root[min[0]].parent = i;
		root[min[1]].parent = i;
	}
	return root;
}

 生成code文件：

        1.只查找叶子结点，并得出单个字符的编码串；

        因为是从叶子往上知道根节点（0节点就是根节点），所以编码串顺序为倒序，通过从后往前取来解决；

        2.获得编码串；

        当前叶子的父母为p，如果它是p的左孩子则存入 0，否则 1

        然后p的父母为q，如果它是q的左孩子则存入 0，否则 1、、（开始套娃！！！）

        直到p==0；

        3.获得codefile.txt文本

        由上得到的是出现字符的编码，有编码记录表记录，遍历源文件source，挨个字符转化为编码串并存入codefile.txt当中；

void codefile(code_graphPtr graph, ListPtr list,record_mapPtr root,char* source) {

	FILE* fp = fopen("D:\\D_desktop\\codefile.txt", "w+");
	if (fp == NULL) return;
	int cat = list->length;
	char* code_str = (char*)malloc(sizeof(char) * (cat + 1));
	code_str[cat] = '\0';
	int start = cat - 1;
	for (int i = 1; i <= cat; i++) {
		graph[i-1].data = root[i].data;
		int p = root[i].parent;
		int child = i;
		while (p != 0) {
			if (root[p].lchild == child) code_str[start--] = '0';
			else code_str[start--] = '1';
			child = p;
			p = root[p].parent;
		}
		strcpy(graph[i-1].str, &code_str[start+1]);
		/*printf("%c---> %s \n", graph[i - 1].data, &code_str[start+1]);
		fputc(graph[i - 1].data, fp);
		fputc(':', fp);
		fputs(graph[i-1].str, fp);
		fputc('\n', fp);*/
		start = cat - 1;
	}
	for (int i = 0; i < strlen(source); i++) {
		for (int j = 0; j < cat; j++) {
			if(source[i]==graph[j].data) fputs(graph[j].str, fp);
		}
	}
	fclose(fp);
}

解码并存入output文件：

        因为每个编码串不可能有重叠部分：每个结点都特意被放在了叶子结点上，如果要有前缀重叠部分就一定得是祖先与后辈的关系！

        通过特定的编码串找回原来的叶子结点（无左右孩子就是其判断条件！）

void decode(int len,record_mapPtr root) {
	FILE* fp = fopen("D:\\D_desktop\\codefile.txt", "r");
	if (fp == NULL) return;
	FILE* fp2 = fopen("D:\\D_desktop\\output.txt", "w+");
	if (fp2 == NULL) return;
	char* code = (char*)malloc(sizeof(char) * Max * len);
	fgets(code, Max * len, fp);
	int R = 2 * len - 1;
	for (int i = 0; i < strlen(code); i++) {
		if (code[i] == '0') R = root[R].lchild;
		if (code[i] == '1') R = root[R].rchild;
		if (root[R].lchild == 0 && root[R].rchild == 0)  // 如果已经是叶子节点，输出到输出文件中，然后重新回到根节点 
		{
			fputc(root[R].data, fp2);
			R = 2 * len - 1;
		}
	}
	fclose(fp);
	fclose(fp2);
}

 效果：

input.txt:

        Life is full of confusing and disordering Particular time,a particular location,Do the arranged thing of ten million time in the brain,Step by step ,the life is hard to avoid delicacy and stiffness No enthusiasm forever,No unexpected happening of surprising and pleasing So,only silently ask myself in mind Next happiness,when will come?

codefile.txt:

        011100010001001111011010000101101100111111010010001010100111001110111111100111100100111111010101000110011101110110001100100101011001000001010011111001001011011110000011001110111010111001010001110001100001111111111010010100011100101011000011110011011110101000101011111000111000110000111111111101001010001110010100100011111111100001100000011110011101001110000001110101100100111011011000111001110010001100111011110110010101011001001000110011101110100111001110101101101110010111110000000100010000001111001010110000111100110110100011001010110010011101101111110111110010000001100111010111110100110110101111101111110110111011010101011011010111110111101001100100111011010010000100111101101000010110101001100011100100101010110001110110000100000001100010010101100101101001000011111110001111110111011011000110010010101010101100001001110011110011010101010110111111000011101110111000110010011111010101000100001011111001011001100111110011010100000110111100111010111110000111011111011100110101000100111111011111110110110110010101010011000011110111111011100000110011101110100111001110101011111011110001111111000000101000110011101110110001100100101010111100101101100001010001100111011101111110100011111010001111000010011101101010100000101101110001100010011101101100001010111001110111110001110101011101001010011101000110010111110000011001001010111111001101010001001101010100110000111101111000110011010101010111101001000010100111011100101010000100000100010101111111001111110011010100011101000110 

​​​​​​​

 完整代码：

#include<stdio.h>
#include<string.h>
#include<malloc.h>

#define Max 1024
#define catage 128//数字 32–126 分配给了能在键盘上找到的字符，当您查看或打印文档时就会出现


typedef struct {
	char ch;
	int count;
}node;

typedef struct {
	node data[catage];//128种
	int length;
}List,*ListPtr;

typedef struct {
	int parent;
	int lchild;
	int rchild;
	int weight;
	char data;
}record_map,*record_mapPtr;//记录表

typedef struct {//unoder_map <char,int>
	char data;
	char* str;
}code_graph, * code_graphPtr;//编码表

ListPtr Init() {
	ListPtr list = (ListPtr)malloc(sizeof(List));
	list->length = 0;
	return list;
}

void Read(char* source) {
	FILE* fp = fopen("D:\\D_desktop\\input.txt", "r+");
	if (fp == NULL) return;
	else {
		fgets(source, Max, fp);
	}
	fclose(fp);
}

void CharCount(ListPtr list, char* source) {
	int ASII[catage];
	memset(ASII, 0, sizeof(int) * catage);
	for (int i = 0; i < strlen(source); i++) {
		ASII[(int)source[i]]++;
		//printf("%c --%d \n", source[i],ASII[source[i]]);
	}
	for (int i = 0; i < catage; i++) {
		if (ASII[i] != 0) {
			//printf("%c --%d \n", i, ASII[i]);
			list->data[list->length].ch = (char)i;//???
			list->data[list->length].count = ASII[i];
			list->length++;
		}
	}
}

void select(int len, int* tow_ints, record_mapPtr root) {
	int min = _CRT_INT_MAX;
	for (int i = 1; i <= len; i++) {
		if (root[i].weight < min && root[i].parent==0) {
			tow_ints[0] = i;
			min = root[i].weight;
		}
	}
	min = _CRT_INT_MAX;
	for (int i = 1; i <= len; i++) {
		if (root[i].weight < min && i != tow_ints[0] && root[i].parent == 0) {
			tow_ints[1] = i;
			min = root[i].weight;
		}
	}
}

record_mapPtr creatHuff(ListPtr list) {
	record_mapPtr root = (record_mapPtr)malloc(sizeof(record_map) * ((list->length) * 2 + 1));
	int total = 2 * list->length - 1;
	for (int i = 0; i <= list->length; i++) {
		root[i].parent = 0;
		root[i].lchild = 0;
		root[i].rchild = 0;
		root[list->length + i].parent = 0;
		root[list->length + i].lchild = 0;
		root[list->length + i].rchild = 0;

		root[i+1].weight = list->data[i].count;
		root[i+1].data = list->data[i].ch;
		//printf("%c ", list->data[i].ch);
	}
	int min[2];
	for (int i = list->length + 1; i <= total; i++) {
		select(i - 1, min, root);
		root[i].lchild = min[0];
		root[i].rchild = min[1];
		root[i].weight = root[min[0]].weight + root[min[1]].weight;
		root[min[0]].parent = i;
		root[min[1]].parent = i;
	}
	return root;
}


code_graphPtr Init_graph(int len) {
	code_graphPtr graph = (code_graphPtr)malloc(sizeof(code_graph)*len);

	for (int i = 0; i < len; i++) {
		graph[i].str = (char*)malloc(sizeof(char) * len);
	}
	return graph;
}


void codefile(code_graphPtr graph, ListPtr list,record_mapPtr root,char* source) {

	FILE* fp = fopen("D:\\D_desktop\\codefile.txt", "w+");
	if (fp == NULL) return;
	int cat = list->length;
	char* code_str = (char*)malloc(sizeof(char) * (cat + 1));
	code_str[cat] = '\0';
	int start = cat - 1;
	for (int i = 1; i <= cat; i++) {
		graph[i-1].data = root[i].data;
		int p = root[i].parent;
		int child = i;
		while (p != 0) {
			if (root[p].lchild == child) code_str[start--] = '0';
			else code_str[start--] = '1';
			child = p;
			p = root[p].parent;
		}
		strcpy(graph[i-1].str, &code_str[start+1]);
		/*printf("%c---> %s \n", graph[i - 1].data, &code_str[start+1]);
		fputc(graph[i - 1].data, fp);
		fputc(':', fp);
		fputs(graph[i-1].str, fp);
		fputc('\n', fp);*/
		start = cat - 1;
	}
	for (int i = 0; i < strlen(source); i++) {
		for (int j = 0; j < cat; j++) {
			if(source[i]==graph[j].data) fputs(graph[j].str, fp);
		}
	}
	fclose(fp);
}

void decode(int len,record_mapPtr root) {
	FILE* fp = fopen("D:\\D_desktop\\codefile.txt", "r");
	if (fp == NULL) return;
	FILE* fp2 = fopen("D:\\D_desktop\\output.txt", "w+");
	if (fp2 == NULL) return;
	char* code = (char*)malloc(sizeof(char) * Max * len);
	fgets(code, Max * len, fp);
	int R = 2 * len - 1;
	for (int i = 0; i < strlen(code); i++) {
		if (code[i] == '0') R = root[R].lchild;
		if (code[i] == '1') R = root[R].rchild;
		if (root[R].lchild == 0 && root[R].rchild == 0)  // 如果已经是叶子节点，输出到输出文件中，然后重新回到根节点 
		{
			fputc(root[R].data, fp2);
			R = 2 * len - 1;
		}
	}
	fclose(fp);
	fclose(fp2);
}




int main() {
	char source[1000];
	Read(source);
	ListPtr list = Init();
	CharCount(list, source);
	record_mapPtr root = creatHuff(list);
	code_graphPtr graph = Init_graph(list->length);
	codefile(graph, list, root,source);
	decode(list->length,root);
	return 0;
}

Songdengdeng～
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
huffman树_Huffman树_C++_huffman_数据结构_
10-02
自己实现huffman树的代码，分享出来
C语言输入与输出
dh爱你的我的博客
11-23 2万+
调试环境：win10+vs2015 声明：本篇博客主要讲怎样使用C语言标准库里面的输入输出函数输入输出简单机制我们在使用输入输出函数的时候，不管是从文件还是控制台，它都是会先存放在缓冲区里面，但需要使用的时候才会在缓冲区里面提取。 例如：#include<stdio.h> int main() { int a, b; scanf("%d %d", &a, &b); pri
INT_MAX和INT_MIN的定义及使用（含溢出问题）
Sun_candong的博客
07-16 1万+
讲述了INT_MAX和INT_MIN的定义以及使用时的注意事项，同时涉及了INT_MAX和INT_MIN的溢出问题
C / C ++和应用程序中的INT_MAX和INT_MIN
Jeff_的博客
01-07 6483
大多数时候，在竞争性编程中，需要分配数据类型可以容纳的变量，最大值或最小值，但是记住如此大而精确的数字是一项困难的工作。因此，C ++有一些宏来表示这些数字，因此可以直接将这些宏分配给变量，而无需实际输入整数。 INT_MAX是一个宏，指定整数变量不能存储超出此限制的任何值。 INT_MIN指定整数变量不能存储低于此限制的任何值。 INT_MAX和INT_MIN的值可能不同， 从编译器到编译...
vs2022 cpp ＜corecrt.h＞注释
weixin_43172531的博客
03-28 213
vs2022 cpp ＜corecrt.h＞注释
C++的 INT_MAX 和 INT_MIN
m0_51913750的博客
12-18 5452
C++ 的 INT_MAX 和 INT_MIN
数据结构 实验五 最小堆 Huffman树
10-27
利用最小堆编程实现给定权值集合下构造相应霍夫曼树的算法，并解决以下问题： 有一电文共使用五种字符a,b,c,d,e,其出现频率依次为4,7,5,2,9。 (1)构造对应的编码哈夫曼树(要求左子树根结点的权小于等于右子树根结点...
数据结构：Huffman编码/译码系统
05-29
Huffman树的编码和译码操作系统，包含两个头文件和对应的源文件，一个测试用的main源文件；欢迎大家学习和交流 1.我将访问的文件名以宏定义的方式放在源文件内，可以自行修改 默认： 读取huffman_test_file.txt---> ...
陈越、何钦铭-数据结构作业17：Huffman Codes哈夫曼编码
05-17
As a professor who gives the final exam problem on Huffman codes, I am encountering a big problem: the Huffman codes are NOT unique. For example, given a string "aaaxuaxz", we can observe that the ...
数据结构与算法-实验五 huffman树
最新发布
11-19
理解哈夫曼树和哈夫曼编码 哈夫曼树和哈夫曼编码：从终端输入若干个字符，统计字符出现的频率，将字符出现的频率作为结点的权值，建立哈夫曼树，然后对各字符进行哈夫曼编码。最后打印哈夫曼树和对应的哈夫曼编码。
【ACM】INT_MAX和INT_MIN注意事项
热门推荐
小小小草儿的博客哟
11-04 2万+
INT_MIN在标准头文件limits.h中定义。#define INT_MAX 2147483647 #define INT_MIN (-INT_MAX - 1)在C/C++语言中，不能够直接使用-2147483648来代替最小负数，因为这不是一个数字，而是一个表达式。表达式的意思是对整数21473648取负，但是2147483648已经溢出了int的上限，所以定义为（-INT_MAX -1）。C
用Crt系列函数分析windows程序的内存泄露
朱金华的专栏
12-19 3126
近几日分析的windows版本一个内存泄露故障，之前之后补了下功课，记录如下，分近10次才补充完整，可能不太连贯。
堆排序——c
c.......p
03-31 128
// 堆排序.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdio.h" #include "malloc.h" #define MAXSIZE 100 typedef struct yuanShu { char data; //数据 int weight; //权值 }YuanShu; YuanShu...
栈ADT--链表实现与数组实现
iEucliwood的博客
12-23 487
栈模型 栈是限制插入和删除只能在一个位置上进行的表，该位置为表的末端，叫做栈顶（top） 。对栈的基本操作有 Push（进栈）和Pop（出栈），前者相当于插入后者相当于删除。 栈有时又叫做LIFO（后进先出-last in first out）。普通的清空栈的操作和判断是否空栈的测试都是栈的操作指令系统的一部分，但是对栈能够做的基本上也就是 Push 和 Pop 操作，也就是说清空栈是通过 Pop 操作来完成的，它没有操作栈，...
【转】关于int范围中负数最小值的绝对值比整数最大值大初学C，问题源自：为什么C中的int类型（16位）的下溢下限为-32768而上溢上限却是32767。 首先说吧，32767很容易理解，32767=
Fighting..
06-25 4091
初学C，问题源自：为什么C中的int类型（16位）的下溢下限为-32768而上溢上限却是32767。 首先说吧，32767很容易理解，32767=2^15-1 （因为要有一个符号位），但为什么下溢的时候分明是15位来表示的数会出现32768呢？？   首先从原码讲起，原码即为计算机中对数值的二进制表示，如 5用二进制表示为0000 0101 ；   其次就是反码，反码
【速过C primer plus】二、三章
qq_35575576的博客
03-14 846
【速过C primer plus】二、三章 文章目录【速过C primer plus】二、三章一、变量命名规则二、保留字三、C语言变量位、字节、字int类型char类型布尔类型浮点类型sizeof() 一、变量命名规则 ​ 长度限制：（C99和C11）对于标识符名，编译器只能识别前63个字符；对于外部标识符，只允许使用31个字符。 ​ 你可以使用大于63个的字符作为标识符名，但是编译器只能识别前63个，导致两个名字长度大于63个字符的不同变量**可能1**会被编译器识别为同一变量。 ​ 1.为什么是可能而
安全函数（后缀为_s）的参数检查和…
Ginvar的专栏
08-19 1667
所有安全（后缀为_s）函数的首要任务是验证传给它们的参数值。要检查的项目包括指针不为NULL，整数在有效范围内，枚举值是有效的，而且缓冲区足以容纳结果数据。如果当中任何一项失败了，函数都会设置局部于线程的C运行时变量errno。然后，并返回一个errno_t值来指出成功或失败。然而这些函数并不实际返回。相反，如果是一次调试版(debug)构建，它会显示一个对用户不太友好的Debug Asserti
c语言实现位数组实现素数最优算法
liyangbinbin的博客
05-23 1292
前几天在广州去面试游戏开发，其中一道题是素数的算法优化，无奈之下，实在想不出，失败后回家宿舍查找了一下资料，目前最优的应该是（不太确定）初等数论的筛选法，用空间换时间的一种思想。 筛选法的具体的说明：https://blog.csdn.net/yangxjsun/article/details/80201735 位数组实现的具说明：https://blog.csdn.net/qq_373754...
数据结构赫夫曼Huffman树算法
05-13
赫夫曼树（Huffman Tree）是一种带权路径长度最短的树，也称为最优二叉树。它是由美国计算机科学家David A. Huffman在1952年发明的，常用于数据压缩算法中。 赫夫曼树的构建过程是基于贪心算法的思想，即每次选取...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值