【算法】哈夫曼压缩算法1-学习记录

最新推荐文章于 2024-07-23 22:06:37 发布
最新推荐文章于 2024-07-23 22:06:37 发布
阅读量159 收藏 2
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43919414/article/details/106374273
版权

目录

开发环境：

DEV C++

代码：

#include <stdio.h>
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include<time.h> 

#define  N 256
#define Maxsize 80
#define  SOME 1
#define Empty 0
#define FULL -1

typedef unsigned long int WeightType;
typedef unsigned char MyType;
typedef struct			//哈夫曼树
{
	MyType ch;		//存字符
	WeightType weight;	/* 用来存放各个结点的权值 */
	int parent, LChild, RChild;	/*指向双亲、孩子结点的指针 */
} HTNode;

typedef struct			//队列
{
	int tag;
	int front;
	int rear;
	MyType length;
	char elem[Maxsize];
} SeqQueue;

void writeFile();
void printHFM(HTNode * ht, int n);
void code(char **hc, int n, unsigned char *ch);

int InitQueue(SeqQueue * Q)
{
	if (!Q)
		return 1;
	Q->tag = Empty;
	Q->front = Q->rear = 0;
	Q->length = 0;

	return 0;
}

int In_seqQueue(SeqQueue * Q, char x)
{
	if (Q->front == Q->rear && Q->tag == SOME)
		return FULL;	//full

	Q->elem[Q->rear] = x;	// printf("in = %c",x);
	Q->rear = (Q->rear + 1) % Maxsize;
	Q->length++;
	Q->tag = SOME;
	return SOME;
}

int Out_Queue(SeqQueue * Q, char *x)
{
	if (Q->tag == Empty)
		return Empty;

	*x = Q->elem[Q->front];
	Q->length--;
	Q->front = (Q->front + 1) % Maxsize;

	if (Q->front == Q->rear)
		Q->tag = Empty;

	return SOME;
}

/* ------------------以上是队列的操作-------------------------  */

void SelectMinTree(HTNode * ht, int n, int *k)
{
	int i, temp;
	WeightType min;

	//      printf(" Selecting……n= %d",n);
	for (i = 0; i <= n; i++) {
		if (0 == ht[i].parent) {
			min = ht[i].weight;	//init min
			temp = i;
			break;
		}
	}
	for (i++; i <= n; i++) {
		if (0 == ht[i].parent && ht[i].weight < min) {
			min = ht[i].weight;
			temp = i;
		}
	}
	*k = temp;
}

// 对哈夫曼树排序，并统计叶子数量
int SortTree(HTNode * ht)
{
	short i, j;
	HTNode tmp;

	for (i = N - 1; i >= 0; i--) {
		for (j = 0; j < i; j++)
			if (ht[j].weight < ht[j + 1].weight) {
				tmp = ht[j];
				ht[j] = ht[j + 1];
				ht[j + 1] = tmp;
			}
	}
	for (i = 0; i < N; i++)
		if (0 == ht[i].weight)
			return i;
	return i;		//返回叶子个数
}

//求哈夫曼0-1字符编码表
char **CrtHuffmanCode(HTNode * ht, short LeafNum)
/*从叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码*/
{
	char *cd, **hc;		//容器
	int i, start, p, last;

	hc = (char **)malloc((LeafNum) * sizeof(char *));	/*分配n个编码的头指针 */

	if (1 == LeafNum)	//只有一个叶子节点时 
	{
		hc[0] = (char *)malloc((LeafNum + 1) * sizeof(char));
		strcpy(hc[0], "0");
		return hc;
	}

	cd = (char *)malloc((LeafNum + 1) * sizeof(char));	/*分配求当前编码的工作空间 */
	cd[LeafNum] = '\0';	/*从右向左逐位存放编码，首先存放编码结束符 */
	for (i = 0; i < LeafNum; i++) {	/*求n个叶子结点对应的哈夫曼编码 */
		start = LeafNum;	/*初始化编码起始指针 */
		last = i;
		for (p = ht[i].parent; p != 0; p = ht[p].parent) {	/*从叶子到根结点求编码 */
			if (ht[p].LChild == last)
				cd[--start] = '0';	/*左分支标0 */
			else
				cd[--start] = '1';	/*右分支标1 */
			last = p;
		}
		hc[i] = (char *)malloc((LeafNum - start) * sizeof(char));	/*为第i个编码分配空间 */
		strcpy(hc[i], &cd[start]);
		//
		//printf("%3d号 %3c 码长:%2d;编码:%s\n", ht[i].ch, ht[i].ch,
		       //LeafNum - start, &cd[start]);
	}			//getchar();
	free(cd);		//     Printcode(hc,n);
	return hc;
}

HTNode *CreatHFM(FILE * fp, short *n, WeightType * FileLength)
{
	HTNode *ht = NULL;
	int i, m, s1, s2;
	MyType ch;

	ht = (HTNode *) malloc(2 * N * sizeof(HTNode));
	if (!ht)
		exit(1);

	for (i = 0; i < N; i++) {
		ht[i].weight = 0;
		ht[i].ch = (MyType) i;	/*1-n号ch 为字符，初始化 */
	}

	for (*FileLength = 0; !feof(fp); ++(*FileLength)) {
		ch = fgetc(fp);	//fread(&ch,1,1,fp);     
		ht[ch].weight++;	//printf("ht[%c].weight= %ld\n",0,ht[0].weight);
	}
	--(*FileLength);	//去掉文件结束后的长度
	*n = SortTree(ht);
	m = *n * 2 - 1;		//free(&ht[m+1]);
	//printf("叶子个数= %d\n",*n);//getchar();
	if (1 == *n) {
		ht[0].parent = 1;
		return ht;
	} else if (0 > *n)
		return NULL;

	for (i = m - 1; i >= 0; i--) {
		ht[i].LChild = 0;
		ht[i].parent = 0;
		ht[i].RChild = 0;
	}
	/*      ------------初始化完毕！对应算法步骤1--------- */
	for (i = *n; i < m; i++)	//创建非叶子结点,建哈夫曼树
	{			//在ht[0]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，其序号分别赋值给s1、s2返回
		SelectMinTree(ht, i - 1, &s1);
		ht[s1].parent = i;
		ht[i].LChild = s1;

		SelectMinTree(ht, i - 1, &s2);
		ht[s2].parent = i;
		ht[i].RChild = s2;

		ht[i].weight = ht[s1].weight + ht[s2].weight;
	}			/*哈夫曼树建立完毕 *///        puts(" over^_^");

	return ht;
}

//从队列里取8个字符（0、1），转换成一个字节
MyType GetBits(SeqQueue * Q)
{
	MyType i, bits = 0;
	char x;

	for (i = 0; i < 8; i++) {
		if (Out_Queue(Q, &x) != Empty) {	//printf("%c",x);
			if ('0' == x)
				bits = bits << 1;
			else
				bits = (bits << 1) | 1;
		} else
			break;
	}			//printf("   bits=%d\n",bits);puts("");

	return bits;
}

//求最长（最短）编码长度
void
MaxMinLength(FILE * File, HTNode * ht, char **hc, short NLeaf, MyType * Max,
	     MyType * Min)
{
	int i;
	MyType length;

	*Max = *Min = strlen(hc[0]);
	for (i = 0; i < NLeaf; i++) {
		length = strlen(hc[i]);
		fwrite(&ht[i].ch, sizeof(MyType), 1, File);	//字符和对应的
		fwrite(&length, sizeof(MyType), 1, File);	//编码长度写进文件
		if (length > *Max)
			*Max = length;
		if (length < *Min)
			*Min = length;
	}
}

//把出现过的字符编码表经过压缩写进文件
short CodeToFile(FILE * fp, char **hc, short n, SeqQueue * Q, MyType * length)
{
	int i;
	char *p;
	MyType j, bits;
	short count = 0;

	for (i = 0; i < n; i++)	// 将n个叶子压缩并写入文件
	{
		for (p = hc[i]; '\0' != *p; p++)
			In_seqQueue(Q, *p);

		while (Q->length > 8) {	//  puts("出队");
			bits = GetBits(Q);	//出队8个元素
			fputc(bits, fp);	//fwrite(&bits,sizeof(char),1,fp);
			//printf("压字符 %c\n",bits);
			count++;
		}
	}			//     printf("码字最后剩: %d\n",Q->length);

	*length = Q->length;
	i = 8 - *length;
	bits = GetBits(Q);	//取8个如果队不空
	for (j = 0; j < i; j++)
		bits = bits << 1;	//printf("压 字符 %c\n",bits);
	fputc(bits, fp);	//fwrite(&bits,sizeof(char),1,fp);
	count++;		//printf(" 指 针 在%d \n",ftell(fp));

	InitQueue(Q);
	return count;
}

//压缩
void Compress()
{
	char desFile[80], rename[80];
	clock_t start,finish;
	start=clock();
	MyType maxLen, minLen, ch, bits, n, finalLength;
	int i;
	short LeafNum, codeNum;
	WeightType count = 0, Length = 0, FileLength;
	FILE *fp, *compressFile;
	SeqQueue *Q;
	HTNode *ht = NULL;
	char **hc = NULL, **Map = NULL, *p;

	printf("filename to be compressed:");
	scanf("%s", desFile);
	//getchar();//fflush(stdin);//清空输入缓冲区域

	printf("filename after compressed:");
	scanf("%s", rename);
	if ('\0' == rename[0]) {
		printf("输入不能为空，请重新输入:");
		scanf("%s", rename);
	}

	compressFile = fopen(rename, "wb");
	fp = fopen(desFile, "rb");	//原文件

	if (!fp || !compressFile) {
		puts("Cannot open file.");
		return;
	}

	ht = CreatHFM(fp, &LeafNum, &FileLength);	//创建哈夫曼树,统计叶子个数和原文件长度
	if (!FileLength) {	//      printf("文件为空，无须压缩...");
		fclose(fp);
		fclose(compressFile);
		free(ht);
		return;
	}
	Q = (SeqQueue *) malloc(sizeof(SeqQueue));
	InitQueue(Q);		//SEEK_SET:文件开头 SEEK_CUR:当前位置 SEEK_END:文件结尾
	hc = CrtHuffmanCode(ht, LeafNum);	//取得哈夫曼0、1编码,hc的长度为LeafNum
	//Map为了取编码好定位，再建立全部(256个)//
	Map = (char **)malloc(N * sizeof(char *));	//字符编码表
	if (!Map) {
		puts("申请空间失败");
		return;
	}

	for (i = 0; i < N; i++)	//初始化
		Map[i] = NULL;

	for (i = 0; i < LeafNum; i++)	// 定位，编码指针数组Map[256]
		Map[(int)(ht[i].ch)] = hc[i];

	fseek(compressFile, sizeof(WeightType) + sizeof(short) + 6 * sizeof(MyType), SEEK_SET);	//先占个位置 
	//先占个位置,等下填压缩叶子编码剩几个和最长编码长//getchar();

	MaxMinLength(compressFile, ht, hc, LeafNum, &maxLen, &minLen);	//获得最长码串长度,顺便填写字符对应编码长
	//      for(i = 0;i < LeafNum;i++)
	//              if(ht[i].ch == (MyType)1)
	//                      printf("char %c %s\n",ht[i].ch,hc[i]);

	free(ht);		//getchar();printf("最长码串长度: %d\n",MaxCode);printf("ftell = %d\n",ftell(compressFile));
	codeNum = CodeToFile(compressFile, hc, LeafNum, Q, &finalLength);	//把字符转成其二进制编码写入文件,返回压成多少个

	rewind(compressFile);	//使文件指针移到开始printf("ftelll = %d\n",ftell(compressFile));
	fseek(compressFile, sizeof(WeightType) + sizeof(MyType), SEEK_SET);
	fwrite(&LeafNum, sizeof(short), 1, compressFile);	//写入叶子个数
	fwrite(&maxLen, sizeof(MyType), 1, compressFile);	//最长码串长度
	fwrite(&minLen, sizeof(MyType), 1, compressFile);	//最短码串长度
	//printf("MaxLen %d Min %d ftell = %d\n",maxLen,minLen,ftell(compressFile));getchar();
	fwrite(&codeNum, sizeof(short), 1, compressFile);	//填写叶子编码压多少个
	fwrite(&finalLength, sizeof(MyType), 1, compressFile);	//最后剩
	//printf("叶子共压：%d个,最后剩%d个\n\n",codeNum,finalLength);

	fseek(compressFile, 2 * LeafNum * sizeof(MyType) + codeNum, SEEK_CUR);
	//printf("开始正文ftell= %d 原文长%d\n",ftell(compressFile),FileLength);getchar();
	fseek(fp, 0, SEEK_SET);
	printf("Please wait a minute,compressing...");

	while (count < FileLength) {
		ch = fgetc(fp);	//fread(&ch,sizeof(MyType),1,fp);        
		++count;	//     printf("Read读 : %c 值 %d %s\n",ch,ch,Map[ch]);
		for (p = Map[ch]; *p != '\0'; p++)
			In_seqQueue(Q, *p);
		//printf("\nQlength: %d\n",Q->length);

		while (Q->length > 8)	//  printf("OutQueue: ");
		{
			bits = GetBits(Q);	//出队8个元素,合成一个字节
			fputc(bits, compressFile);	//fwrite(&bits,1,1,compressFile);      
			Length++;	//     printf("压：%c\n",bits);
		}
	}			//end of while
	//最后一个bits ;
	finalLength = Q->length;	//printf("最后剩Qlength:%d\n",Q->length);
	n = 8 - finalLength;
	bits = GetBits(Q);
	//printf("最后Qlength:%d\n",Q->length);
	for (i = 0; i < n; i++)
		bits = bits << 1;	//以‘0’补
	//fputc(bits,compressFile);
	fwrite(&bits, sizeof(MyType), 1, compressFile);	//printf("\nfinal压：%c\n",bits);
	Length++;

	rewind(compressFile);	//原文件长fwrite(&FileLength,sizeof(WeightType),1,compressFile);
	fwrite(&Length, sizeof(WeightType), 1, compressFile);	//压缩后的长
	fwrite(&finalLength, sizeof(char), 1, compressFile);	//最后的串长

	Length = Length + 12 + codeNum;	//printf("原文件长 %ld;压缩后 %ld\n",FileLength,Length);
	finish=clock();
	if (Length >= FileLength)
		puts("\nCompression rate: 0.0%");
	else
	{
		printf("\nCompression rate: %.2lf%c\n",
		       (double)((FileLength -
				 Length) / (double)FileLength) * 100.0, '%');
		//printf("Time consume: %lf secs\n",(double)(finish-start)/1000000);
			}

	fclose(fp);
	fclose(compressFile);
	free(Q);
	free(hc);
	free(Map);
}

//把读出的字符，转换成8个0、1字符串并入队
void ToQueue(SeqQueue * Q, MyType ch)
{
	int i;
	MyType temp;

	for (i = 0; i < 8; i++) {
		temp = ch << i;
		temp = temp >> 7;
		if (1 == temp)
			In_seqQueue(Q, '1');	//printf("1");
		else
			In_seqQueue(Q, '0');	//printf("0");
	}			//puts("");
}

//解压缩
void UnCompress()
{
	MyType *str, MaxLength, MinLength, ch, *num, finalLength = 0, final = 0;
	clock_t start,finish;
	start=clock();
	FILE *cf, *uf;
	short NLeaf, Ncom;
	char CName[N], UName[N], **hc, *p, x, *buf;
	SeqQueue *Q = NULL;
	int i, j;
	WeightType srcLen = 0, thisFile = 0;

	fflush(stdin);		//清空输入缓冲区域
	printf("filename to be uncompressed:");
	scanf("%s", CName);
	if (CName[0] == '\0') {
		printf("try again:");
		scanf("%s", CName);
		fflush(stdin);
	}
	fflush(stdin);		//清空输入缓冲区域
	printf("filename after uncompressed:");
	scanf("%s", UName);
	if (UName[0] == '\0') {
		printf("try again:");
		scanf("%s", UName);
	}

	cf = fopen(CName, "rb");
	uf = fopen(UName, "wb");
	if (!cf || !uf) {
		puts("Cannot open files.");
		return;
	}

	fread(&srcLen, sizeof(WeightType), 1, cf);	//printf("压后文件长：%ld\n",srcLen);
	fread(&finalLength, 1, 1, cf);	//   printf("原文件压剩:%d个\n",finalLength);
	fread(&NLeaf, sizeof(short), 1, cf);	//printf("叶子:%d个\n",NLeaf);
	fread(&MaxLength, sizeof(MyType), 1, cf);
	fread(&MinLength, sizeof(MyType), 1, cf);
//printf("MaxLength = %d;minLen= %d,Leaf= %d\n",MaxLength,MinLength,NLeaf);getchar();
	Q = (SeqQueue *) malloc(sizeof(SeqQueue));

	buf = (char *)malloc((2 + MaxLength * sizeof(char)));
	str = (MyType *) malloc(NLeaf * sizeof(MyType));
	num = (MyType *) malloc(NLeaf * sizeof(MyType));
	//压缩叶子数量x和最后剩长
	if (!Q || !str || !num || !buf) {
		puts("Memery error.");
		exit(1);
	}
	InitQueue(Q);		//初始化

	fread(&Ncom, sizeof(short), 1, cf);
	fread(&final, sizeof(MyType), 1, cf);

	for (i = 0; i < NLeaf; i++)	//读取叶子及其码长
	{
		fread(&str[i], sizeof(MyType), 1, cf);
		fread(&num[i], sizeof(MyType), 1, cf);
		//printf("chars= %c;num= %d\n",Chars[i],CHlength[i]);
	}
	//printf("read ftell= %d\n",ftell(cf));//getchar();
	//      printf("\n叶子码字压缩后%d个,最后剩%d个\n",Ncom,final);

	hc = (char **)malloc((NLeaf) * sizeof(char *));	//hc为编码表的指针数组
	if (!hc)
		exit(1);

	--Ncom;			//printf("开始取叶子编码ftell = %d Ncom=%d\n",ftell(cf),Ncom);
	for (j = i = 0; i < Ncom; i++) {
		ch = fgetc(cf);	//fread(&ch,1,1,cf);
		ToQueue(Q, ch);	//printf("Q->Len= %d\n",Q->length);
		while (Q->length > MaxLength) {
			hc[j] = p = (char *)malloc(1 + num[j]);
			for (ch = 0; ch < num[j]; ch++) {
				Out_Queue(Q, &x);
				*p++ = x;
			}
			*p = '\0';	//printf("%c编 码%s\n",str[j],hc[j]);
			j++;
		}
	}
	ch = fgetc(cf);		//fread(&ch,1,1,cf);//最后一个
	ToQueue(Q, ch);
	final = 8 - final;
	while (Q->length > final) {
		p = hc[j] = (char *)malloc(1 + num[j]);
		for (ch = 0; ch < num[j]; ch++) {
			Out_Queue(Q, &x);
			*p++ = x;
		}
		*p = '\0';	//printf("%c编码%s\n",str[j],hc[j]);getchar();
		j++;
	}

	InitQueue(Q);
	--srcLen;
	--MinLength;
	//printf("开始解压正文%d ,压后长= %d\n",ftell(cf),srcLen);getchar();
	printf("Please wait a minute,uncompressing...");
	while (thisFile < srcLen) {
		//      printf("QLength= %d\n",Q->length);
		ch = fgetc(cf);	//fread(&ch,sizeof(MyType),1,cf);
		ToQueue(Q, ch);
		thisFile++;	//   printf("char:%c",ch);
		//完了后队列长于码串的最大值       

		while (Q->length > MaxLength) {
			for (i = 0; i < MinLength; i++) {
				Out_Queue(Q, &x);
				buf[i] = x;
			}
			for (; i < MaxLength; i++) {
				Out_Queue(Q, &x);
				buf[i] = x;
				buf[i + 1] = '\0';
				for (j = 0; j < NLeaf; j++) {
					if (i + 1 == num[j]
					    && 0 == strcmp(hc[j], buf)) {
						ch = str[j];	//printf("出队 %s\n",buf);
						fputc(ch, uf);	//fwrite(&ch,1,1,uf);printf("解   出：%c\n",ch);
						break;
					}
				}
				if (j < NLeaf)
					break;
			}
		}		//while MaxLength
	}

	ch = fgetc(cf);		//fread(&ch,1,1,cf);//读取最后一个压缩字getchar();
	ToQueue(Q, ch);

	finalLength = 8 - finalLength;
	while (Q->length > finalLength) {
		for (i = 0; i < MinLength; i++) {
			Out_Queue(Q, &x);
			buf[i] = x;
		}
		for (; i < MaxLength; i++) {
			Out_Queue(Q, &x);
			buf[i] = x;
			buf[i + 1] = '\0';
			for (j = 0; j < NLeaf; j++) {
				if (i + 1 == num[j] && 0 == strcmp(hc[j], buf)) {
					ch = str[j];	//printf("出 %s\n",buf);
					fputc(ch, uf);	//fwrite(&ch,1,1,uf);//printf("解   出：%c\n",ch);
					break;
				}
			}
			if (j < NLeaf)
				break;
		}
	}
	finish=clock();
	//printf("Time consume: %lf secs\n",(double)(finish-start)/1000000);
	//printf("Q->length= %d\n",Q->length);printf("ftell= %d\n",ftell(uf));
	free(Q);
	free(str);
	free(num);
	free(hc);
	fclose(uf);
	fclose(cf);
}

int main(int argc, char *argv[])
{
	char choice, blank[] = "              ";
	//      writeFile();
	while (1) {
		printf("\n\n\n\n");
		puts("          * * * *Welcome use huffman encoder\\decoder* * *");
		puts("          **********************^_^***********************");
		puts("          *                                              *");
		printf("          * %s 1 ]. Compress   %s*\n", blank, blank);
		puts("          *                                              *");
		printf("          * %s 2 ]. Uncompress%s *\n", blank, blank);
		puts("          *                                              *");
		printf("          * %s 3 ]. Exit  ^_^ %s *\n", blank, blank);
		puts("          *                                              *");
		puts("          ************************************************");
		printf("          Choose (1 to 3):");
		choice = getchar();

		puts("");
		getchar();
		fflush(stdin);	//清空输入缓冲区域，否则键入的回车符将作为程序结尾处的scanf输入，此函数在stdio.h中
		switch (choice) {
		case '1':
			Compress();
			printf("Press Enter to continue...");
			getchar();
			break;
		case '2':
			UnCompress();
			printf("\nPress Enter to continue...");
			getchar();
			break;
		case '3':
			return 0;
			break;
		}
	}

	return 0;
}

/*----------------------------END----------------------------------------*/
LimCC
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【算法】哈夫曼压缩算法-学习记录
weixin_43919414的博客
05-27 174
目录开发环境：代码： 开发环境： DEV C++ 代码： #include<iostream> #include<conio.h> #include<cstring> #include<vector> #include<fstream> #include<queue> #include<ctime> using namespace std; long node[256];//用于存储ASCII码在文件中出现的频率 st
基于huffman的文件压缩
iamubbTing的博客
11-27 856
算法思想： 1、哈夫曼数的建立 我使用类的方法建立哈夫曼数的 。首先建立一个节点类，包含了一个char字符，int型的权重，int型左右孩子和父节点的下标，以及char类型的code数组，里面存放的是0101的编码，最后还有这个code的长度，用于最后计算平均码长。 char data;//字符  charcode[50];//编码  intweight;//权重  int lchil
哈夫曼编码
weixin_42861049的博客
08-07 3623
一、哈夫曼编码的特性及作用 哈夫曼编码的目的是得到平均长度最短的编码，对一棵具有n个叶子的哈夫曼树，若对树中的每个左分支赋予0，右分支赋予1（也可调换顺序），则从根到每个叶子的通路上，各分支的赋值分别构成一个二进制串，该二进制串就称为哈夫曼编码。哈夫曼编码是前缀编码，因为在所以叶子所构成的二进制串中，任一编码都不是其他编码的前缀，哈夫曼编码是最优前缀编码，使用频度较高的字符对应的编...
已知哈夫曼树总顶点数求叶子结点数
fu_jian_ping的博客
04-13 2万+
题目： 已知一棵哈夫曼树有13个顶点，求其叶子结点的个数。 分析： 首先，哈夫曼树是一个二叉树；第二点，哈弗曼树的度只有两种情况，一是只有两个度的结点，二是没有度的结点，即叶子结点。明确这两点之后，做该题就非常简单了。 解题： 设分支结点个数为a, 叶子结点个数为b,则有以下连个关系式： a + b = 13 2*a + 1 = 13 根据以上两个式子可以求得: b =...
0023算法笔记——【贪心算法】哈夫曼编码问题--16页.pdf
09-05
算法以|C|个叶结点开始，执行|C|－1次的“合并”运算后产生最终所要求的树T。假设编码字符集中每一字符c的频率是f(c)。以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。 哈夫曼...
HuffmanCompress_编码_哈夫曼压缩算法_
09-29
哈夫曼压缩算法在实际应用中广泛用于文本、图像和音频等数据的压缩，特别是在数据传输和存储空间有限的情况下，它可以显著减少文件大小。但需要注意的是，哈夫曼编码适用于无损压缩，即解压后能够完全恢复原始数据，...
C语言-基于哈夫曼树的数据压缩算法.zip
11-15
哈夫曼编码是一种高效的数据压缩算法，它利用了字符出现频率的不同来构建特殊的二叉树——哈夫曼树（Huffman Tree），进而为每个字符分配一个唯一的二进制编码，频繁出现的字符会得到较短的编码，不常出现的字符则...
基于哈夫曼树的数据压缩算法c源码.zip
11-15
哈夫曼编码是一种高效的数据压缩算法，它利用了数据的频率特性进行编码，频繁出现的字符用较短的编码，不频繁的字符用较长的编码，这样可以使得整体的编码长度最短，从而达到压缩数据的目的。在C语言中实现哈夫曼...
哈夫曼压缩解压算法-C语言
05-16
mypage文件可能包含了实现哈夫曼压缩和解压缩算法的C源代码文件，以及相关的测试数据或结果。通过阅读和理解这些代码，你可以深入学习哈夫曼编码的工作原理，以及如何在C语言中实现这一算法。同时，还可以了解到如何...
关于goland中的unsafe.sizeof() 函数详解
weixin_40456226的博客
07-22 1286
切片的内存大小 slice := []int{1,2,3} fmt.Println(unsafe.Sizeof(slice)) //24 上面声明了一个切片，然后打印出sizeof的值为24，但是不管slice里的元素为多少，sizeof返回的数据都是24。 原因：官方文档解释 Sizeof takes an expression x of any type and returns the si...
构造哈夫曼树和哈夫曼编码的算法实现
weixin_44008781的博客
01-09 2474
1、实验内容： 统计下面一段英文的不同字符个数和每个字符的出现频率，利用统计数据构造构造哈夫曼树和哈夫曼编码 The Chinese official said he viewed the Trump Presidency not as an aberration but as the product of a failing political system. This jibes with o...
哈夫曼压缩总结
咸鱼
10-27 538
由于最近笔者比较忙,所以总结做的比较粗糙,请谅解 1.链表 链表作为哈夫曼压缩的基础,所以由链表说起(双向) 链表的几个要素: 1.链表的节点:由节点元素(节点的储存值), 2.链表节点的联系:此处由人为的定义,由此演化出单向,双向,环链表 3.特别说明的是链表的循环遍...
哈夫曼树
热门推荐
D_Double's Journey
03-11 15万+
一、哈夫曼树的概念和定义   什么是哈夫曼树？ 让我们先举一个例子。 判定树：         在很多问题的处理过程中，需要进行大量的条件判断，这些判断结构的设计直接影响着程序的执行效率。例如，编制一个程序，将百分制转换成五个等级输出。大家可能认为这个程序很简单，并且很快就可以用下列形式编写出来：   if(score<60) cout<<"Bad"<<endl; e
Huffman压缩解压的思考
点滴记录 不断进步
02-12 5162
转自于http://imba-marlboro.iteye.com/blog/889143 历时10多天，文件压缩终于能用了。从最开始的构造huffman树到最后的解压缩，遇到了不少纠结的难题。下面就和大家分享一下做文件压缩的心得。            1.构建huffman树。由于数据结构基础有限，也想不到高明的压缩方法，便只能用书上的一种简单而实用的方法---huffman编码。Huff
数据结构实验5 哈夫曼树&哈夫曼编码
一半西瓜的博客
10-11 5785
赞赏码 & 联系方式 & 个人闲话 实验内容： 哈夫曼编码的实现，首先的是根据给定的n个权值构造哈夫曼树。通过遍历此二叉树完成哈夫曼编码。 代码 #include<stdio.h> #include<stdlib.h> #define maxvalue 10000 #define maxleaf 30 #define maxnode 59 #def...
算法-KMP字符串匹配
最新发布
xx_xb的博客
07-23 234
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 884
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 281
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
第1关：基于哈夫曼树的数据压缩算法
05-09
哈夫曼压缩算法通过构建哈夫曼树来实现数据压缩，它的基本思想是将出现频率较高的字符用较短的二进制编码表示，出现频率较低的字符用较长的二进制编码表示。 具体实现步骤如下： 1. 统计字符出现的频率，生成字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值