HuffmanTreeCode.c

最新推荐文章于 2021-09-17 16:05:18 发布
最新推荐文章于 2021-09-17 16:05:18 发布
阅读量250 收藏
点赞数
分类专栏： C 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42103865/article/details/107167876
版权

HuffmanTree

I leaned it about few months ago, then I found this and decided to upload it.

The code part:

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

#define ALPHABET_LENGTH 26
char alphabet[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'n', 'm', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int alphabet_weights[] = {817, 149, 278, 425, 1270, 223, 202, 609, 697, 15, 77, 403, 241, 675, 751, 193, 10, 599, 633, 906, 276, 98, 236, 15, 197, 7};


typedef struct{
	int weight;
	int parent, lchild, rchild;
} HTNode, *HuffmanTree;

//HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的俩个结点在数组中的位置
void Select(HuffmanTree HT, int end, int *s1, int *s2){
	int min1, min2;
	//遍历数组初始下标为1
	int i = 1;
	//找到还没构建树的结点
	while(HT[i].parent != 0 && i <= end){
		i++;
	}
	min1 = HT[i].weight;
	*s1 = i;
	
	i++;
	while(HT[i].parent != 0 && i <= end){
		i++;
	}
	//对找到的俩个结点比较大小，min2为大的，min1为小的
	if(HT[i].weight < min1){
		min2 = min1;
		*s2 = *s1;
		min1 = HT[i].weight;
		*s1 = i;
	}
	else{	
		min2 = HT[i].weight;
		*s2 = i;
	}
	//俩个结点和后续的所有未构建成树的结点作比较
	for(int j = i + 1; j <= end; j++){
		//如果有父结点，直接跳过，进行下一个
		if(HT[j].parent != 0){
			continue;
		}
		//如果比最小的还小，将min2 = min1, min1赋值新的结点的下标
		if(HT[j].weight < min1){
			min2 = min1;
			min1 = HT[j].weight;
			*s2 = *s1;
			*s1 = j;
		}
		else if(HT[j].weight >= min1 && HT[j].weight < min2){
			min2 = HT[j].weight;
			*s2 = j;
		}
	}
}


void CreateHuffmanTree(HuffmanTree &HT, int weights[], int n){
	if (n < 1){
		return;
	}
	
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];		//0号位不用
	//初始化
	for (int i = 1; i <= m; i++){
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
	}
	for (int i = 1; i <= n; i++){
		HT[i].weight = weights[i - 1];
	}
	
	for (int i = n + 1; i <= m; i++){
		int min1, min2;
		Select(HT, i, &min1, &min2);
		HT[i].weight = HT[min1].weight + HT[min2].weight;
		HT[i].lchild = min1;
		HT[i].rchild = min2;
		HT[min1].parent = HT[min2].parent = i;
	}
}

//HuffmanCodeTable
typedef char **HuffmanCodeTable;

void CreateHuffmanCode(HuffmanTree HT, HuffmanCodeTable &HC, int n){
	HC = new char *[n + 1];			//Huffman编码表数组
	char *cd = new char[n];			//分配临时存放编码的动态数组空间
	cd[n - 1] = '\0';
	for (int i = 1; i <= n; i++){  	//对每个叶子结点求解Huffman编码
		int start = n - 1;			
		int c = i;
		int f = HT[i].parent;		
		while (f != 0){				//从叶子向上回溯，直到根结点
			start--;				//回溯一次start向前指的位置
			if (HT[f].lchild == c){		
				cd[start] = '0';		//左孩子生成代码0
			}
			else{
				cd[start] = '1';		//右孩子生成代码1
			}
			c = f;
			f = HT[f].parent;			//继续回溯
		}

		HC[i] = new char[n - start];	//为第i个字符编码分配空间
		strcpy(HC[i], &cd[start]);		//求得的编码从临时空间复制到HC
	}	
	
	delete[] cd;						//释放临时空间	
}

int main(){
	HuffmanTree ht;
	CreateHuffmanTree(ht, alphabet_weights, ALPHABET_LENGTH);
		printf("Alphabet\tNode\t|Weight\t\t|Parent\t|Lchild\t|Rchild\t|\n");	
	for (int j = 1; j <= ALPHABET_LENGTH * 2 - 1; j++){
		HTNode node = ht[j];
		if (j <= ALPHABET_LENGTH){
			printf("%c", alphabet[j - 1]);
		}
		printf("\t\t%d\t|%d\t|\t|%d\t|%d\t|%d\t|\n", j, node.weight, node.parent, node.lchild, node.rchild);
	}

	HuffmanCodeTable hc;
	CreateHuffmanCode(ht, hc, ALPHABET_LENGTH);
	printf("Alphabet\tNode\tAlphabet_weights->\tEncode\n");
	for (int j = 1; j <= ALPHABET_LENGTH; j++){
		if (j <= ALPHABET_LENGTH){
			printf("%c", alphabet[j - 1]);
		}
		printf("\t\t%d\t%d\t\t->\t%d\n", j, alphabet_weights[j - 1], hc[j]);
	}
	
	//输入单词
	char text[100];
	printf("========== Input your Text ==========\n");
	scanf("%s", &text);
	
	//编码
	int text_len = strlen(text);
	char *encoded_text = new char[text_len * ALPHABET_LENGTH];
	int start = 0;								//每个字母的起始位置
	
	for (int i = 0; i < text_len; i++){			//开启循环逐个判断字符串进行编码
		char c = text[i];
		int index = c - 'a' + 1;				//利用ascii码匹配权重值
		char *huffman_code = hc[index];			
		strcpy(encoded_text + start, huffman_code);	//把当前字符串进行编码
		start += strlen(huffman_code);				
	}
	
	printf("******* Encode Completed *******\n%s\n", encoded_text);
	
	//解码
	int root_index = 1;					
	
	while (ht[root_index].parent != 0){				//直到找到根节点才能进行解码
		root_index++;	
	}
	
	char decoded_text[100];							//解码存储位置
	int cur = 0;									//做当前编码存储位置
	int encode_len = strlen(encoded_text);			//获取编码字符串长度
	int l = 0;										//带入编码循环
		
	while (l < encode_len){
		int p = root_index;							//利用p判断路径（伪指针）
		
		while (ht[p].lchild != 0 || ht[p].rchild != 0){		//直到叶子结点才停止
			char code = encoded_text[l++];					//寻找叶子结点
			if (code == '0'){								//0为左孩子1为右孩子
				p = ht[p].lchild;
			}
			else{
				p = ht[p].rchild;
			}
		}
		
		decoded_text[cur] = 'a' + p - 1;					//导入到解码存储空间
		cur++;
	}
	decoded_text[cur] = '\0';
	
	printf("******* Decode Completed *******\n%s\n", decoded_text);
	
	return 0;
}

Output:(not included the decode or encode part)

Alphabet        Node    |Weight         |Parent |Lchild |Rchild |
a               1       |817    |       |44     |0      |0      |
b               2       |149    |       |32     |0      |0      |
c               3       |278    |       |36     |0      |0      |
d               4       |425    |       |38     |0      |0      |
e               5       |1270   |       |47     |0      |0      |
f               6       |223    |       |34     |0      |0      |
g               7       |202    |       |33     |0      |0      |
h               8       |609    |       |41     |0      |0      |
i               9       |697    |       |42     |0      |0      |
j               10      |15     |       |28     |0      |0      |
k               11      |77     |       |30     |0      |0      |
l               12      |403    |       |38     |0      |0      |
n               13      |241    |       |35     |0      |0      |
m               14      |675    |       |42     |0      |0      |
o               15      |751    |       |43     |0      |0      |
p               16      |193    |       |32     |0      |0      |
q               17      |10     |       |27     |0      |0      |
r               18      |599    |       |40     |0      |0      |
s               19      |633    |       |41     |0      |0      |
t               20      |906    |       |45     |0      |0      |
u               21      |276    |       |36     |0      |0      |
v               22      |98     |       |31     |0      |0      |
w               23      |236    |       |35     |0      |0      |
x               24      |15     |       |28     |0      |0      |
y               25      |197    |       |33     |0      |0      |
z               26      |7      |       |27     |0      |0      |
                27      |17     |       |29     |26     |17     |
                28      |30     |       |29     |10     |24     |
                29      |47     |       |30     |27     |28     |
                30      |124    |       |31     |29     |11     |
                31      |222    |       |34     |22     |30     |
                32      |342    |       |37     |2      |16     |
                33      |399    |       |37     |25     |7      |
                34      |445    |       |39     |31     |6      |
                35      |477    |       |39     |23     |13     |
                36      |554    |       |40     |21     |3      |
                37      |741    |       |43     |32     |33     |
                38      |828    |       |44     |12     |4      |
                39      |922    |       |45     |34     |35     |
                40      |1153   |       |46     |36     |18     |
                41      |1242   |       |46     |8      |19     |
                42      |1372   |       |47     |14     |9      |
                43      |1492   |       |48     |37     |15     |
                44      |1645   |       |48     |1      |38     |
                45      |1828   |       |49     |20     |39     |
                46      |2395   |       |49     |40     |41     |
                47      |2642   |       |50     |5      |42     |
                48      |3137   |       |50     |43     |44     |
                49      |4223   |       |51     |45     |46     |
                50      |5779   |       |51     |47     |48     |
                51      |10002  |       |0      |49     |50     |
Alphabet        Node    Alphabet_weights->      Encode
a               1       817             ->      10039184
b               2       149             ->      10039200
c               3       278             ->      10038904
d               4       425             ->      10038920
e               5       1270            ->      10030968
f               6       223             ->      10030984
g               7       202             ->      10031000
h               8       609             ->      10031016
i               9       697             ->      10031032
j               10      15              ->      10031048
k               11      77              ->      10031072
l               12      403             ->      10031088
n               13      241             ->      10031104
m               14      675             ->      10031120
o               15      751             ->      10031136
p               16      193             ->      10031152
q               17      10              ->      10031168
r               18      599             ->      10031192
s               19      633             ->      10031208
t               20      906             ->      10031248
u               21      276             ->      10031264
v               22      98              ->      10031280
w               23      236             ->      10031296
x               24      15              ->      10032248
y               25      197             ->      10031312
z               26      7               ->      10032272

CodeJugend
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
F分布的C/C++代码
Do What U Like~
05-14 3133
#include #include #include double FDist(double F,double m,double n); double betainv(double p,double a,double b); double betainc(double x,double a, double b); double beta(double z,double w); double ga
数据结构14：哈夫曼树的创建和编码
qq_70132617的博客
05-29 4157
摘要： 哈夫曼树是十分重要的，常用于压缩的编码和解码。但写起来也比较折磨。 迟到的代码，实在抱歉。上代码！ 一.代码块 其实由于哈夫曼树结点的度要么为0，要么为2，并且输入的编码的元素必为 叶节点，所以n个元素也就是n个叶节点的哈夫曼树必为2n-1个总结点。知道了结点个数，我们肯定更喜欢用顺序存储（数组）来存储哈夫曼树，而孩子和双亲则类似于静态链表，用下标代替地址 1）结构体定义 typedef struct huffmanTree { char data; int weight; int lchil
使用c:forEach 控制5个换行
weixin_33811961的博客
08-11 1916
        今天做项目的时候碰到一个问题，我须要显示不确定数目的图片在网页上（图片是从数据库查出来的），用的是&lt;c:forEach&gt;循环取值的。就须要做成一行显示固定个数的图片。代码例如以下（我这里是控制5个一行）： &lt;table&gt; &lt;c:forEach items="${list}" var="obj" varStatus="status"&g..
OJ Problem C: 求个最大值
is_kkk的博客
07-15 512
** Problem C: 求个最大值 ** Description： 定义MaxValue类，用于求一系列非零整数的最大值。其中： 数据成员elements用于存储所有输入的非零整数。 void append(int)用于向elements中添加一个新数据。 int getMax()用于求出elements中的最大值。 Input输入若干个整数，以输入0表示输入结束。 Output所有输入的非零整数中的最大值。 Sample Input 321 496 553 338 837 463 158 154
Error C2662， cannot convert ‘this’ pointer from ‘const class ’ to ‘class &’
小郭学路的专栏
04-20 9291
class Point3d{public: Point3d(float x=0.0,float y=0.0,float z=0.0) :_x(x),_y(y),_z(z) { } float GetX() {return _x;} float GetY() {return _y;} float GetZ() {return _z;}private:
c语言构造哈夫曼树-哈夫曼编码
热门推荐
快乐的孙悟空的博客
12-05 2万+
构造哈夫曼树 首先，我们需要了解哈夫曼树是什么： 一．相关知识点 路径： 路径是指从一个节点到另一个节点的分支序列。 路径长度： 指从一个节点到另一个结点所经过的分支数目。 ，从根节点到a的分支数目是2， 数的路径长度： 树中所有结点的路径长度之和为树的路径长度PL 如图pl为10 节点的权： 给树的每个结点赋予一个具有某种实际意义的实数，我们称该实数为这个结点的权 带权路径长度： 从树根...
哈夫曼编码C代码实现--数据结构
可爱的LYF的博客
06-14 3377
哈夫曼编码的实现过程 请读者结合上一篇哈夫曼树的博客，便于理解该篇文章。简单来说，哈夫曼编码是将构造的哈夫曼树按照左孩子都标记为0 右孩子都标记为1的原则。通过此种标记的手段标记的哈弗曼树能够将编码的长度压缩到最小。本程序中默认将权值较小置为左孩子。 代码实现如下 可能不是主流思路，只是看了原理自己手写的。望指正！ 文末附有测试过程 #include <stdio.h> #inclu...
哈夫曼树和哈夫曼编码
njaumj的博客
04-28 390
1.带权最短路径wpl 2.哈夫曼树是wpl最小的树，但树不一定唯一。左右子树交换，大于二的同权重的树的任意组合都会影响其唯一性。 3.n个叶子节点的总节点数为2n-1。 4.哈夫曼树的建立，每次将两个权重最小的树组合一个大树（小树消失，大树插入。这里的存在与否依据parent标记），直到还有一棵树为止。 5.4可知哈夫曼树没有度为1的结点，又**n**0=**n**2+1。所以可得结论3.
使用哈夫曼树将字符重新编码(压缩数据)
apqop的博客
09-17 142
huffmanTree.c #include "huffmanTree.h" HuffmanTree new_huffman_tree_node(data_size data) { //申请对内存给节点 HuffmanTree tmp = (HuffmanTree)malloc(sizeof(HuffmanTreeNode)); if(tmp != NULL) //申请成功 { tmp->parentNode = 0; tmp-&
c++哈夫曼编码译码代码
11-16
void HuffmanTreeCode(HuffmanTree HT){ int i; char* temp; temp = (char*)malloc(n * sizeof(char)); temp[n - 1] = '\0'; int p; int s; for (i = 0; i ; i++) { p = i; s = n - 1; while (HT[p]....
huffman编码与译码
04-03
`HuffmanTreeCode`函数实现了译码过程，通过回溯找到字符的编码。`GetCodingSen`函数接收要编码的句子，而`HuffmanTreeEncoding`函数负责对句子进行编码。 在实际应用中，为了提高效率和减少内存占用，通常会使用位...
int main() { int num;//元素个数 printf("请输入元素个数："); scanf("%d",&num); getchar(); // 读取并丢弃回车符 char letter[num];//元素名称 float value[num];//元素权值 printf("请分别输入元素名称和其权值：\n"); printf("名称,权值\n"); for(int i=0;i<num;i++) { scanf("%c,%f",&letter[i],&value[i]); getchar(); // 读取并丢弃回车符 } // CreatHuffmanTree(HT,value,num); // HuffmanTreecode(HT,num,letter); return 0; }循环为啥执行不完
最新发布
06-06
循环可能执行不完的原因在于输入元素名称和... scanf("%c,%f",&letter[i],&value[i]); getchar(); // 读取并丢弃回车符 } // CreatHuffmanTree(HT,value,num); // HuffmanTreecode(HT,num,letter); return 0; } ```
Huffman的应用之文件压缩与解压缩
微风
10-30 4644
文件压缩与解压缩>      最近这段时间一直在学习树的这种数据结构,也接触到了Huffman树以及了解了什仫是Huffman编码,而我们常用的zip压缩也是利用的Huffman编码的特性，那仫是不是可以自己实现一个文件压缩呢？当然可以了.在文件压缩中我实现了Huffman树和建堆Heap的代码，下面开始介绍思路...      1).统计>读取一个文件统计这个文件中字符出现的次数.
Vs_Code对c进行debug的时候遇到的一个问题以及解决方案
风茶
10-17 8558
之前在vscode进行debug调试的时候就会发生这个问题，这个问题也是我找了几天百度也到现在才成功解决的 （图为网页随机找图截取，问题一样，我解决的时候已经没有这个提示了所也懒得改回来刻意截图了） 这个时候下面的终端也会有以下提示 Unable to start debugging. Program path '***.exe' is missing or invalid. GDB failed with message: "***.exe": not inexecutable format:
Stack.h(c)
风茶
04-08 1788
#include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int Stat...
ax^2+bx+c=0(c)
风茶
04-08 679
#include <stdio.h> #include "math.h" main(){ float a, b, c, disc, x1, x2, realpart, imagpart; scanf("%f, %f, %f", &a, &b, &c); printf("The quation"); if (fabs(a) <= 0.000001) ...
CLinkList（仅学习用）
风茶
04-08 290
#include <stdio.h> #include <stdlib.h> typedef struct CLinkList{ int data; struct CLinkList *next; }node; void InitLinkList(node **pNode); //初始化链表 void Insert(node **pNode...
Calculate the days of year(c)
风茶
04-08 231
#include <stdio.h> int counting(int year, int month, int day); main(){ int y, m, d; int days; printf("date input:\n"); printf("Year:\n"); scanf("%d", &y); printf("M...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值