devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

空间数据结构--哈夫曼树

作者：我家自动化 | 2024-07-08 12:53:47

赞

踩

空间数据结构--哈夫曼树

6.3 遍历二叉树和线索二叉树

6.3.1 遍历二叉树

二叉树的3个基本单元：根节点、左子树、右子树

若限定先左后右可分为：先序遍历、中序遍历、后序遍历

先序遍历：

  1. void printBT(BinTree* T) {
  2. 	if (T == NULL) {
  3. 		printf("空\n");
  4. 		return;
  5. 	}
  6. 	else {
  7. 		printf("%c ", T->data);
  8. 		printBT(T->lchild);
  9. 		printBT(T->rchild);
  10. 	}
  11. }

中序遍历：

  1. void printBT2(BinTree* T) {
  2. 	if (T == NULL) {
  3. 		printf("空\n");
  4. 		return;
  5. 	}
  6. 	else {
  7. 		printBT2(T->lchild);
  8. 		printf("%c ", T->data);
  9. 		printBT(T->rchild);
  10. 	} 
  11. }

后序遍历：

  1. void printBT2(BinTree* T) {
  2. 	if (T == NULL) {
  3. 		printf("空\n");
  4. 		return;
  5. 	}
  6. 	else {
  7. 		printBT2(T->lchild);
  8.         printBT(T->rchild);
  9. 		printf("%c ", T->data);
  10. 		
  11. 	} 
  12. }

树与表达式：

Q1:已知树->后序表达式->逆波兰式计算

Q2:已知有先序和中序->推算出后序

先序：a b d e c f g h i

中序:  d e b a f c h g i

复原二叉树并求出后序:

6.6 赫夫曼树

赫夫曼（Huffman）树，又称最优树，是一类带权路径长度最短的树，有着最广泛的应用

6.6.1最优二叉树（哈夫曼树）

路径：从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径

路径长度：路径上的分支数目

树的路径长度：从树根到每一结点的路径长度之和

结点的带权路径长度:结点权与该结点到树根之间的路径长度乘积

树的带权路径长度：……

最优二叉树/哈夫曼树：带权路径长度最小的二叉树

哈夫曼算法叙述：

（1）根据给定n个权值构成n棵二叉树的集合，F={T1,T2,T2……}，每棵二叉树Ti中只有一个带权wi的根节点，其左右子树均空

（2）F中选取两颗根结点的权值最小的树作为左右子树，作为左右子树构造一棵新的二叉树，且重置新的二叉树的根结点的权值为其左、右子树上根结点的权值之和

（3）删除这两棵树，将新树加入

（4）重复

6.6.2哈夫曼编码

基础：创建哈夫曼树

上机要求：根据序列与权重，生成哈夫曼树

init code    by 废阿柴    2024/04/22

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<memory.h>
  4. typedef struct {
  5. 	char ch;
  6. 	unsigned weight;
  7. 	int parent, lchild, rchild;
  8. }HTNode;
  9. const char* infilename = "D:\\c practice data\\huffman_source.txt";
  10. const unsigned int Min=65535;
  11. //1.创建哈夫曼树
  12. HTNode* createHuffTree(const char* infilename,int *n);
  13. //1.1打印HuffTree
  14. void printHuffTree(HTNode* hTree,int n);
  15. //1.2打印每个字符的huffman编码
  16. void printHuffCode(HTNode* hTree, int i);
  17.  
  18. //找到最小权重的下标
  19. int findMin(HTNode* Htree, int i);
  20.  
  21. int main() {
  22. 	int n=0;
  23. 	HTNode* Htree = createHuffTree(infilename,&n);
  24. 	printHuffTree(Htree,n);
  25. 	for (int i = 0; i < n; i++) {
  26. 		printf("%c %d:",Htree[i].ch,Htree[i].weight);
  27. 		printHuffCode(Htree, i);
  28. 		printf("\n");
  29. 	}
  30. 	free(Htree);
  31. 	return 0;
  32. }
  33. //1.创建哈夫曼树
  34. HTNode* createHuffTree(const char* infilename, int* n) {
  35. 	//1.打开文件
  36. 	FILE* fp = fopen(infilename, "r");
  37. 	if (fp == NULL) {
  38. 		printf("error\n");
  39. 		return NULL;
  40. 	}
  41. 	fscanf(fp, "%d\n", n);
  42. 	HTNode* Htree = (HTNode*)malloc((2*(*n) - 1)*sizeof(HTNode));
  43. 	memset(Htree, 0, (2 * (*n) - 1) * sizeof(HTNode));
  44. 	//2.初始化哈夫曼树
  45. 	for (int i = 0; i < (*n);i++) {
  46. 		char ch;
  47. 		int weight;
  48. 		fscanf(fp, "%c %d\n", &ch, &weight);
  49. 		Htree[i].ch = ch;
  50. 		Htree[i].weight = weight;
  51. 		Htree[i].parent = Htree[i].lchild=Htree[i].rchild=-1;
  52. 	}
  53. 	fclose(fp);
  54. 	//3.利用算法重建哈夫曼树
  55. 	for (int i = (*n); i < (*n)*2 - 1; i++)//这是因为n后都是空的，不需要找
  56. 	{
  57. 		int n1 = findMin(Htree, i);
  58. 		int n2 = findMin(Htree, i);
  59. 		Htree[i].parent = -1;
  60. 		Htree[i].lchild = n1;
  61. 		Htree[i].rchild = n2;
  62. 		Htree[i].weight = Htree[n1].weight + Htree[n2].weight;
  63. 		Htree[n1].parent = Htree[n2].parent = i;
  64. 	}
  65. 	return Htree;
  66. }
  67.  
  68. //1.1打印HuffTree
  69. void printHuffTree(HTNode* hTree, int n) {
  70. 	for (int i = 0; i < 2*n-1; i++) {
  71. 		printf("%d:%c %d %d %d %d\n",i, hTree[i].ch, hTree[i].weight, hTree[i].parent, hTree[i].lchild, hTree[i].rchild);
  72. 	}
  73. }
  74. //1.2打印每个字符的huffman编码
  75. void printHuffCode(HTNode* hTree, int i) {
  76. 	int parent = hTree[i].parent;
  77. 	//打印的字符一定是叶子结点，那么parent一定不为-1；
  78. 	if (parent == -1) {
  79. 		return;
  80. 	}//递归一定要在开始时设置返回条件
  81. 	printHuffCode(hTree, parent);
  82. 	int child=-1;
  83. 	if (hTree[parent].lchild == i)//为什么是i?
  84. 		child = 0;
  85. 	if (hTree[parent].rchild == i)
  86. 		child = 1;
  87. 	printf("%d", child);
  88. 	return ;//-----------
  89. }
  90. //找到最小权重的下标
  91. //需要注意的是，有parent的不参与排序（需要排除）
  92. int findMin(HTNode* Htree, int n) {
  93. 	int target=-1;
  94. 	unsigned int finMin = Min;
  95. 	for (int i = 0; i < n; i++) {
  96. 		if ((Htree[i].weight < finMin) && Htree[i].parent ==-1) {
  97. 			finMin = Htree[i].weight;
  98. 			target = i;
  99. 		}
  100. 	}//如何找到倒数第二大的？前一个做标记
  101. 	Htree[target].parent = 0;//这样找n2时就排除了前一个最小的
  102. 	return target;
  103. }
进阶：对文本文件的英文字符利用Huffman算法进行压缩，再重新解压

上机要求：
（1）对指定的英文文本文件字符出现频率进行统计，获得权重表

（2）利用权重表创建哈夫曼树

（3）利用哈夫曼树对文本文件进行编码压缩

（4）对压缩编码进行解压缩

init code    by 废阿柴    2024/04/29

（1）定义哈夫曼树、码表结构以及压缩、解压两个函数

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<memory.h>
  5. const char* srcFilename = "D:\\c practice data\\Huffman\\no_zip.txt";
  6. const char* zipFilename = "D:\\c practice data\\Huffman\\zip.dat";
  7. const char* unzipFilename = "D:\\c practice data\\Huffman\\unzip.txt";
  8. const unsigned int Min=65536;
  9. //定义哈夫曼树
  10. typedef struct {
  11. 	char ch;
  12. 	unsigned int weight;
  13. 	unsigned int len;//编码长度
  14. 	char* code;
  15. 	int parent, lchild, rchild;
  16. }HTNode;
  17. //定义码表结构
  18. typedef struct {
  19. 	bool isValid;
  20. 	int len;
  21. 	char* code;
  22. }HTCode;
  23.  
  24. //1.对文件进行压缩、构建哈夫曼树、获取压缩编码、存入文件
  25. bool huffZip(const char* srcFilename, const char* zipFilename);
  26.  
  27. //创建哈夫曼树
  28. HTNode* createHuffTree(int weightTable[], int n);
  29. //找到权重最小值
  30. int findMin(HTNode* Htree, int n);
  31. //删除哈夫曼树
  32. void deleteHuffTree(HTNode* Htree, int n);
  33.  
  34. //2.对已压缩文件进行解压，并且保存
  35. bool huffUnzip(const char* zipFilename, const char* unzipFilename);

位操作：方便对后续压缩编码进行按位存储

  1. // 取出index位，若取出的index位为0，则GET_BYTE 值为假，否则为真
  2. #define GET_BYTE(vbyte, index) (((vbyte) & (1 << ((index) ^ 7))) != 0)
  3. // 把index位设置为‘1’
  4. #define SET_BYTE(vbyte, index) ((vbyte) |= (1 << ((index) ^ 7)))
  5. // 把index位设置为‘0’ 
  6. #define CLR_BYTE(vbyte, index) ((vbyte) &= (~(1 << ((index) ^ 7))))

主函数部分

  1. int main(int argc,char*argv[]) 
  2. {
  3. 	printf("开始压缩……\n");
  4. 	if (huffZip(srcFilename, zipFilename)) {
  5. 		printf("压缩成功\n");
  6. 	}
  7. 	else {
  8. 		printf("压缩失败!\n");
  9. 		return -1;
  10. 	}
  11. 	printf("开始解压缩……\n");
  12. 	if (huffUnzip(zipFilename, unzipFilename)) {
  13. 		printf("解压缩成功\n");
  14. 	}
  15. 	else {
  16. 		printf("解压缩失败！\n");
  17. 		return -1;
  18. 	}
  19. 	return 0;
  20. }

压缩文件函数——创建二叉树+找到权重最小值+删除二叉树，释放存储空间

  1. //创建哈夫曼树
  2. HTNode* createHuffTree(int weightTable[], int n) {
  3. 	HTNode* Htree = nullptr;
  4. 	Htree = (HTNode*)malloc(sizeof(HTNode) * (2 * n - 1));
  5. 	memset(Htree, 0, sizeof(HTNode) * (2 * n - 1));
  6. 	int index = 0;
  7. 	for (int i = 0; i < 256; i++) {
  8. 		if (weightTable[i] > 0) {
  9. 			Htree[index].ch = (char)i;
  10. 			Htree[index].weight = weightTable[i];
  11. 			Htree[index].len = 0;
  12. 			Htree[index].code = nullptr;
  13. 			Htree[index].parent = Htree[index].lchild = Htree[index].rchild = -1;
  14. 			index++;
  15. 		}
  16. 	}
  17. 	//重新构造哈夫曼树
  18. 	for (int i = n; i < 2 * n - 1; i++) {
  19. 		int m1 = findMin(Htree, i);
  20. 		int m2 = findMin(Htree, i);
  21. 		Htree[i].weight = Htree[m1].weight + Htree[m2].weight;
  22. 		Htree[i].parent = -1;
  23. 		Htree[i].lchild = m1;
  24. 		Htree[i].rchild = m2;
  25. 		Htree[m1].parent = Htree[m2].parent = i;
  26. 	}
  27. 	return Htree;
  28. }
  29.  
  30. //找到权重最小值
  31. int findMin(HTNode* Htree, int n) {
  32. 	int target = -1;
  33. 	unsigned int fMin = Min;
  34. 	for (int i = 0; i < n; i++) {
  35. 		if (Htree[i].weight < fMin && Htree[i].parent == -1) {
  36. 			fMin = Htree[i].weight;
  37. 			target = i;
  38. 		}
  39. 	}
  40. 	Htree[target].parent = 0;
  41. 	return target;
  42. }
  43. //删除哈夫曼树
  44. void deleteHuffTree(HTNode* Htree, int n) {
  45. 	for (int i = 0; i < n; i++) {
  46. 		if (Htree[i].code != nullptr) {
  47. 			free(Htree[i].code);
  48. 		}
  49. 	}
  50. 	free(Htree);
  51. 	return;
  52. }

1.对文件进行压缩、构建哈夫曼树、获取压缩编码、存入文件（huffZip函数）

  1. bool huffZip(const char* srcFilename, const char* zipFilename) {
  2. 	//1.1对文件进行读取，统计出现的字符和频率，频率作为权重
  3. 	FILE* fp = fopen(srcFilename, "r");
  4. 	int n=0;//定义字符种类总数
  5. 	int  weightTable[256] ;
  6. 	memset(weightTable, 0, sizeof(int) * 255);//清除内存中的一些垃圾
  7. 	char ch;
  8. 	while (!feof(fp)) {
  9. 		ch = fgetc(fp);
  10. 		//首先先判断是否是规定的字符
  11. 		if (ch > 255 || ch < 0)
  12. 			continue;
  13.            
  14.         //若ch第一次出现，种类加1
  15. 		if (weightTable[ch] == 0) {
  16. 			n += 1;//
  17. 		}
  18. 		weightTable[ch]++;//每次读入一个，对应table位置+1
  19. 	}
  20. 	fclose(fp);
  21. 	fp=NULL;
  22.  
  23. 	//按照权重构建哈夫曼树
  24. 	HTNode* Htree = createHuffTree(weightTable,n);
  25.  
  26. 	//针对创建的Huffman树计算字符编码
  27. 	HTCode codeTable[256];
  28. 	memset(codeTable, 0, sizeof(HTCode) * 256);
  29. 	for (int i = 0; i < n; i++) {
  30. 		//从每个叶子结点开始
  31. 		HTNode temp = Htree[i];
  32. 		while (temp.parent != -1) 
  33. 		{
  34. 		//限定只有前n个才是叶节点
  35. 		 //获取字符长度
  36. 			Htree[i].len += 1;
  37. 			int parent = temp.parent;
  38. 			temp = Htree[parent];
  39. 		}
  40.  
  41. 	    //开辟编码长度对应的存储空间
  42. 		Htree[i].code = (char*)malloc(sizeof(char) * Htree[i].len);
  43. 		memset(Htree[i].code, 0, sizeof(char) * Htree[i].len);
  44.  
  45. 	     //计算编码
  46. 		temp = Htree[i];
  47. 		int index = 0;
  48. 		int current = i;
  49. 		while (temp.parent != -1) {
  50. 			int parent = temp.parent;
  51. 			int child = -1;
  52. 			if (Htree[parent].lchild == current) {
  53. 				child = 0;
  54. 			}
  55. 			else if (Htree[parent].rchild == current) {
  56. 				child = 1;
  57. 			}
  58. 			Htree[i].code[Htree[i].len - 1 - index] = child;//这里需要仔细思考
  59. //由于从叶子结点到根结点，因此获得的0-1序列存储要在code申请的内存空间中倒着存
  60. 			index++;
  61. 			temp = Htree[parent];
  62. 			current = parent;
  63. 		}
  64.  
  65. 	     //从HTNode的code复制到码表codeTable中
  66. 		codeTable[Htree[i].ch].isValid = true;
  67. 		codeTable[Htree[i].ch].len = Htree[i].len;
  68. 		codeTable[Htree[i].ch].code = (char*)malloc(sizeof(char) * Htree[i].len);
  69. 		memcpy(codeTable[Htree[i].ch].code, Htree[i].code, sizeof(char) * Htree[i].len);//copy
  70. 	}
  71.  
  72. 	//码表写入二进制压缩文件
  73. 	FILE* zipfp = fopen(zipFilename,"wb");//注意是wb
  74.  
  75. 	//先写入字符类型数
  76. 	fwrite(&n, sizeof(int), 1, zipfp);
  77.  
  78. 	//再写入末尾无效编码数
  79. 	int invalidCount = 0;
  80. 	fwrite(&invalidCount, sizeof(int), 1, zipfp);
  81.  
  82. 	//写入字符权重表
  83. 	fwrite(weightTable, sizeof(int), 256, zipfp);
  84.  
  85. 	//原始文件编码写入压缩文件
  86. 	//重新打开fp文件
  87. 	fp = fopen(srcFilename, "r");
  88. 	char byte=0;
  89. 	int bitindex=0;
  90. 	while (!feof(fp)) {
  91. 		char ch = fgetc(fp);
  92. 		//判断拉丁文
  93. 		if ((int)ch < 0 ||(int) ch>=256) {
  94. 			continue;
  95. 		}
  96. 		HTCode hCode = codeTable[ch];
  97.  
  98. 		//对hCode的code进行位操作
  99. 		for (int i = 0; i < hCode.len; i++) {
  100. 			if (hCode.code[i]==0) {
  101. 				CLR_BYTE(byte, bitindex);
  102. 			}
  103. 			else {
  104. 				SET_BYTE(byte, bitindex);
  105. 			}
  106. 			//判断是否读满一个字节
  107. 			if (bitindex == 7) {
  108. 				fwrite(&byte, sizeof(char), 1, zipfp);
  109. 				bitindex = 0;
  110. 			}//之所以需要判断为7是因为，实际上此时已经是满8位了
  111. 			else { bitindex++; }
  112. 		}
  113. 	}
  114.  
  115. 	//读完for循环还需要考虑，是不是最终除以8有余数
  116. 	if (bitindex != 0)
  117. 		fwrite(&byte, sizeof(char), 1, zipfp);//剩余的0-1码仍然以char字节大小读入，但是标记
  118. 	invalidCount = 8 - (bitindex+1);//为什么-1-------因为bitindex是从0开始的，而位是从1开始的
  119. 	
  120.     //存储一下invalidcount（这里我还没搞懂）
  121. 	fseek(zipfp, sizeof(int), 0);
  122. 	fwrite(&invalidCount, sizeof(int), 1, zipfp);
  123. 	fclose(fp);
  124. 	fclose(zipfp);
  125.  
  126. 	//释放内存空间
  127. 	for (int i = 0; i < 256; i++) {
  128. 		if(codeTable[i].code!=nullptr)
  129. 		    free(codeTable[i].code);
  130. 	}
  131.  
  132. 	deleteHuffTree(Htree, n);
  133. 	return true;
  134. }

2.对已压缩文件进行解压，并且保存(huffUnzip函数)

  1. bool huffUnzip(const char* zipFilename, const char* unzipFilename) {
  2. 	FILE* zipfp = fopen(zipFilename, "rb");
  3. 	int n = 0;
  4.  
  5. 	//读入字符种类总数
  6. 	fread(&n, sizeof(int),1, zipfp);
  7.  
  8. 	//读入末尾无效位数
  9. 	int invalidCount = 0;
  10. 	fread(&invalidCount, sizeof(int), 1, zipfp);
  11.  
  12. 	//读入权重表
  13. 	int weightTable2[256];
  14. 	fread(weightTable2, sizeof(int), 256, zipfp);
  15. 	
  16. 	//根据权重表创建新的哈夫曼树
  17. 	HTNode* Htree2 = createHuffTree(weightTable2, n);
  18.  
  19. 	//开始对字符解码，存入目标文件unzipfp
  20. 	FILE* unzipfp = fopen(unzipFilename, "w");
  21.  
  22. 	//找到树根位置
  23. 	int current = 2 * n - 1 - 1;//初始位置为HuffTree树的树根
  24. 	while (!feof(zipfp)) {//按照char字节读zipfp
  25. 		char byte;
  26. 		fread(&byte, sizeof(char), 1, zipfp);
  27.  
  28. 		int len = 8;
  29. 		if (feof(unzipfp)) {//一直不太懂这里什么意思
  30. 			//到了文件末尾需要考虑无效位
  31. 			len = len - invalidCount;//----------------------------------
  32. 		}
  33.  
  34.         //
  35. 		for (int i = 0; i < len; i++) {
  36. 			if (GET_BYTE(byte, i) == 0) {
  37. 				current = Htree2[current].lchild;
  38. 			}
  39. 			else {
  40. 				current = Htree2[current].rchild;
  41. 			}
  42. 			if (Htree2[current].lchild == -1 && Htree2[current].rchild == -1) {
  43. 				//到达叶节点
  44. 				fprintf(unzipfp, "%c", Htree2[current].ch);
  45. 				current = 2 * n - 1 - 1;
  46. 			}
  47. 		}
  48. 	}
  49. 	fclose(zipfp);
  50. 	fclose(unzipfp);
  51. 	deleteHuffTree(Htree2, n);
  52.  
  53. 	return true;
  54. }

有潜藏Bug 待修改……

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/798812
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号