个人笔记--HuffmanTree哈夫曼树（赫夫曼树）及哈夫曼编码

最新推荐文章于 2024-06-03 21:04:16 发布
原创 最新推荐文章于 2024-06-03 21:04:16 发布 · 3.2k 阅读 · 64 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文详细讲解了如何通过哈夫曼树算法，根据字母频率构建编码表，并以实例演示如何为26个字母和空格生成哈夫曼编码。涵盖了从数据输入、树的构建到编码生成和实际应用的过程。
部署运行你感兴趣的模型镜像

哈夫曼树的构建及哈夫曼编码的生成与转换

哈夫曼编码，即根据字母出现的频率对其进行编码，适用于频率参差不齐的情况。

哈夫曼树的建树过程（重点）
举个例子 A B C D E五个字母出现的频率依次为5 4 1 3 8
先把他们存储在一个数组里，因为还要相加取父类，所以一共需要2*5-1=9个位置（这里0位置弃用，以便填写下标）
初始化1-5的权值

下标0123456789
weight0541380000
parent0000000000
lchild0000000000
rchild0000000000

第一次遍历，找到最小的两个权值（1,3）下标为3,4，将这两个权值相加赋值到下标为6的weight上，并且将 下标3 和 4 的parent改为 新建权值的下标 将 新建节点的左右子树 改为两个节点的 下标

下标0123456789
weight0541384000
parent0006600000
lchild0000003000
rchild0000004000

第二次遍历，找到最小的两个权值且parent为0（4,4）的下标2,6，同理

下标0123456789
weight0541384800
parent0076607000
lchild0000003200
rchild0000004600

…
最终为

下标0123456789
weight054138481321
parent0876687990
lchild0000003217
rchild0000004658

哈夫曼树到这就构建好了

哈夫曼编码的生成（重点）
然后求每个字符的哈夫曼编码
举个例子，就上面建成的树求5的哈夫曼编码
从5这个节点开始找他的父类，如果父类不为0（父类为0即代表根节点）判断5是他父类的左孩子还是右孩子，左孩子就存储0，右孩子就存储1（注意是 逆序存储，也可以用栈存储）。然后再以5的父类为参照，找他的父类判断是否为0…（循环）
最终得出5的哈夫曼编码是11
如题：
给定报文中26个字母a-z及空格的出现频率{64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1, 168}，构建哈夫曼树并为这27个字符编制哈夫曼编码，并输出。模拟发送端，从键盘输入字符串，以%为结束标记，在屏幕上输出输入串的编码；模拟接收端，从键盘上输入0-1哈夫曼编码串，翻译出对应的原文。

头文件及结构体部分

#include<bits/stdc++.h>//C++万能头文件
#define inf 0x3f3f3f3f//将inf设为最大（至于为什么是0x3f3f3f3f可以自行百度）
using namespace std;

typedef struct{
	int weight;//权值
	int parent,lchild,rchild;//父，左孩子和右孩子
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树
typedef char **HuffmanCode;//动态分配数组存储哈夫曼编码表，两个*号是因为是二维数组

输入参数

void HuffmanCout(int *a)//传入a的首地址
{
	for(int i=0;i<27;i++)
		cin>>a[i];//输入26个英文字母及空格出现的频率
}

初始化HuffmanTree参数

void HuffmanInit(HuffmanTree &HT,int *w,int n)//w存放n个字符的权值
{
	int i;
	HuffmanTree p;
	if(n<=1)
		return ;
	int m=2*n-1;//共m个元素，即n + n+1
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0单元未用，所以申请m+1个空间
	for(p=HT+1,i=1;i<=n;++i,++p,++w)//传入的p和w都是数组的首地址，++p和++w即右移一位
		*p={*w,0,0,0};//1~n依次存入对应的权值w
	for(;i<=m;++i,++p)
		*p={0,0,0,0};//n+1~m依次初始化0
}

创建HuffmanTree和编码表

void Select(HuffmanTree &HT,int end,int &s1,int &s2)//选择函数，选择数组中权值最小的两个元素的下标
{
	int min1=inf,min2=inf;//初始化min1和min2为最大值
	for(int i=1;i<=end;++i)
	{
		if(HT[i].parent==0 && HT[i].weight<min1)//HT[i].parent==0即没有使用的元素
		{
			min1=HT[i].weight;
			s1=i;//找到权值最小元素的下标
		}
	}
	for(int i=1;i<=end;++i)
	{
		if(HT[i].parent==0 && HT[i].weight<min2 && i!=s1)//i！=s1即第二小
		{
			min2=HT[i].weight;
			s2=i;//找到权值第二小元素的下标
		}
	}
}

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
	int s1,s2;//为后面最小的两个权值
	int m=2*n-1;
	for(int i=n+1;i<=m;++i)//构建哈夫曼树
	{
		Select(HT,i-1,s1,s2);//找最小的两个数
		HT[i].weight=HT[s1].weight+HT[s2].weight;//下标i的权值，两孩子权值之和
		HT[s1].parent=i;
		HT[s2].parent=i;//两个孩子的母亲的下标都是i
		HT[i].lchild=s1;//下标i的左孩子，最小
		HT[i].rchild=s2;//右孩子，第二小
	}
	//从叶子到根逆向求每个字符的哈夫曼编码
	HC=(HuffmanCode)malloc((n+1)*sizeof(char *));//分配n个字符编码的头指针向量
	char *cd;
	cd=(char *)malloc(n*sizeof(char));//创建字符型数组cd
	cd[n-1]='\0';//编码结束符
	for(int i=1;i<=n;++i)//逐个字符求哈夫曼编码
	{
		int start=n-1;//编码结束符的位置，没错，逆序存储
		for(int c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到根逆向求编码
		{//初始c=i，f=i的父；循环完c=c的父，f=f的父（往后一辈）；直到f！=0，根节点了
			if(HT[f].lchild==c)	cd[--start]='0';//如果c是f的左孩子，逆序存储一个0
			else cd[--start]='1';//否则就逆序存储一个1
		}
		HC[i]=(char *)malloc((n-start)*sizeof(char));//为第i个字符编码分配空间，（n-start）个元素空间，即从start到n。
		strcpy(HC[i],&cd[start]);//strcpy是字符串copy函数，即从数组cd的start位置开始到结束这段区间内的字符赋值给HC[i]。
	}
		free(cd);//释放cd
}

输出编码表

void showHuffmanCode(HuffmanCode HC) //显示每个字符的赫夫曼编码 
{
	char c ; 
	for(int i=1;i<=27;++i){
		if(i!=27)//前26个是字母
		 {
		 	c=i+'a'-1;
		 	cout<<c<<"的赫夫曼编码是："; 
		 }
		else//第27个是空格
		{
			cout<<"空格的赫夫曼编码是：";
		}
		for(int j=0;HC[i][j]!='\0';++j)
		{//依次输出数组HC[i]里的字符（0或1），直到末尾的'\0'不输出
			cout<<HC[i][j];
		}
		//注意：这里的HC数组是二维数组
		cout<<endl;
	} 
}

输入编码，翻译为字符（模拟接收端）

void TanserHuffmanCode(HuffmanCode HC,string s)//s为编码
{
	string ss="",s1="";//初始化ss和s1均为空字符串
	string t[27];//27个t字符串存26个字母和空格的编码
	for(int i=0;i<27;++i)
	{
		t[i]="";
		for(int k=0;HC[i+1][k]!='\0';++k)
			t[i]+=HC[i+1][k];//就是把编码表逐一赋值给t
//		cout<<' '<<t[i]<<endl;
	}
	
	for(int i=0;i<s.size();++i)//字符串匹配算法，非KMP，最普通的暴力算法
	{
		ss+=s[i];//取编码元素赋值给ss，+号代表字符串连接符
		for(int j=0;j<27;++j)//注意j从0开始（因为t从0开始，这样写方便）
		{
			if(ss==t[j])//与第j个t进行匹配
			{//匹配成功，即找到相应编码对应的字符
				ss="";//ss初始化为空，重新选取编码
				if(j!=26)//不是第27个字符就存储对应的字母
					s1+=j+'a';
				else//空格情况
					s1+=' ';
			}
			//匹配不成功，++j，与下一个t匹配
		}
	//若都不成功，则++i，取下一个编码元素，再进行匹配
	}
	cout<<s1<<endl;//输出字符串s1，破译完成
}

输入字符，转换成编码（模拟发送端）

void TanserString(HuffmanCode HC,string s)//s为字符
{
	string ss;
	for(int i=0;i<s.length();++i)
	{
		if(s[i]>='A' && s[i]<='Z')
			s[i]+=32;//大写字母全部转换为小写，因为此编码程序不区分大小写，统统按小写
		else if(s[i]==' ')
			s[i]='z'+1;//空格就转换为ASCII码表z的下一位
	}
	for(int i=0;i<s.length();++i)
	{
		for(int j=0;HC[s[i]-'a'+1][j]!='\0';++j)//依次遍历全部字符
			ss+=HC[s[i]-'a'+1][j];//每个字符的编码都贴到ss上
	}
	cout<<ss<<endl;//输出ss，即字符串的编码，加密成功
}

完整代码

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;

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

void HuffmanCout(int *a)
{
	for(int i=0;i<27;i++)
		cin>>a[i];
}

void HuffmanInit(HuffmanTree &HT,int *w,int n)
{
	int i;
	HuffmanTree p;
	if(n<=1)
		return ;
	int m=2*n-1;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
	for(p=HT+1,i=1;i<=n;++i,++p,++w)
		*p={*w,0,0,0};
	for(;i<=m;++i,++p)
		*p={0,0,0,0};
}

void Select(HuffmanTree &HT,int end,int &s1,int &s2)
{
	int min1=inf,min2=inf;
	for(int i=1;i<=end;++i)
	{
		if(HT[i].parent==0 && HT[i].weight<min1)
		{
			min1=HT[i].weight;
			s1=i;
		}
	}
	for(int i=1;i<=end;++i)
	{
		if(HT[i].parent==0 && HT[i].weight<min2 && i!=s1)
		{
			min2=HT[i].weight;
			s2=i;
		}
	}
}

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
	int s1,s2;
	int m=2*n-1;
	for(int i=n+1;i<=m;++i)
	{
		Select(HT,i-1,s1,s2);
		HT[i].weight=HT[s1].weight+HT[s2].weight;
		HT[s1].parent=i;
		HT[s2].parent=i;
		HT[i].lchild=s1;
		HT[i].rchild=s2;
	}
	
	HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
	char *cd;
	cd=(char *)malloc(n*sizeof(char));
	cd[n-1]='\0';
	for(int i=1;i<=n;++i)
	{
		int start=n-1;
		for(int c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
		{
			if(HT[f].lchild==c)	cd[--start]='0';
			else cd[--start]='1';
			HC[i]=(char *)malloc((n-start)*sizeof(char));
			strcpy(HC[i],&cd[start]);
		}
		free(cd);
	}
} 
void showHuffmanCode(HuffmanCode HC) 
{
	char c ; 
	for(int i=1;i<=27;++i){
		if(i!=27)
		 {
		 	c=i+'a'-1;
		 	cout<<c<<"的赫夫曼编码是："; 
		 }
		else
		{
			cout<<"空格的赫夫曼编码是：";
		}
		for(int j=0;HC[i][j]!='\0';++j)
		{
			cout<<HC[i][j];
		}
		cout<<endl;
	} 
}

void TanserHuffmanCode(HuffmanCode HC,string s)
{
	string ss="",s1="";
	string t[27];
	for(int i=0;i<27;++i)
	{
		t[i]="";
		for(int k=0;HC[i+1][k]!='\0';++k)
			t[i]+=HC[i+1][k];
//		cout<<' '<<t[i]<<endl;
	}
	
	for(int i=0;i<s.size();++i)
	{
		ss+=s[i];
		for(int j=0;j<27;++j)
		{
			if(ss==t[j])
			{
				ss="";
				if(j!=26)
					s1+=j+'a';
				else
					s1+=' ';
			}
		}
	}
	cout<<s1<<endl;
}

void TanserString(HuffmanCode HC,string s)
{
	string ss;
	for(int i=0;i<s.length();++i)
	{
		if(s[i]>='A' && s[i]<='Z')
			s[i]+=32;
		else if(s[i]==' ')
			s[i]='z'+1;
	}
	for(int i=0;i<s.length();++i)
	{
		for(int j=0;HC[s[i]-'a'+1][j]!='\0';++j)
			ss+=HC[s[i]-'a'+1][j];
	}
	cout<<ss<<endl;
}
void menu()
{
	cout << "************************************************************" << endl;
	cout << "********   1.输入HuffmanTree的参数                      ****" << endl;
	cout << "********   2.初始化HuffmanTree参数.《含有26字母及空格》 ****" << endl;
	cout << "********   3.创建HuffmanTree和编码表。                  ****" << endl; 
	cout << "********   4.输出编码表。                               ****" << endl;
	cout << "********   5.输入编码，并翻译为字符。                   ****" << endl;
	cout << "********   6.输入字符，并实现转码                       ****" << endl;
	cout << "********   7.退出                                       ****" << endl;
	cout << "************************************************************" << endl;
}

int main()
{
	HuffmanTree HT;
	HuffmanCode HC;
	string s;
	HC = (HuffmanCode) malloc ((27+1) * sizeof(char *));
	for(int i=1;i<=28;i++)
		HC[i]=(char *)malloc((27+1)*sizeof(char));
	menu();
	int a[27];
	int order;
	do
	{
		cout<<"请输入操作："<<endl;
		cin>>order;
		switch(order)
		{
			case 1:	
				cout<<"请输入HuffmanTree的参数："<<endl;
				HuffmanCout(a);
				cout<<"输入完毕"<<endl;
				break;
			case 2:
				HuffmanInit(HT,a,27);
				cout<<"HuffmanTree的参数初始化完成"<<endl;
				break;
			case 3:
				HuffmanCoding(HT,HC,a,27);
				cout<<"创建成功"<<endl;
				break;
			case 4:
				showHuffmanCode(HC);
				break;
			case 5:	
				getchar();
				cout<<"请输入HuffmanCode：";
				getline(cin,s);
				TanserHuffmanCode(HC,s);
				break;
			case 6:
				getchar();
				cout<<"请输入字符：";
				getline(cin,s);
				TanserString(HC,s);
				break;
			case 7:
				cout<<"程序已退出"<<endl;
				break;
			default :
				cout<<"输入违法"<<endl;
				break;
		}
	}while(order!=7);
	return 0;
}
//64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 18 1 16 1 168

“所有的努力，不是为了让别人觉得你了不起，而是为了能让自己打心眼里看得起自己。”

您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

C语言实现霍夫曼编码算法
Book_Sea的博客
08-28 476
这里我们定义了一个名为"HuffmanNode"的结构体，该结构体包含了节点权值、左右子树的指针以及是否为叶子节点的标志。通过这个例子，我们可以看到，在想要将一个文件压缩的时候，若其数据分布不均匀，则考虑霍夫曼编码可能会是更好的选择。以下是C语言实现霍夫曼编码的算法，包含完整的源代码和相应的描述。b. 创建一个新的节点，将这个节点的权值设为两个最小节点的权值之和，并将这个节点作为这两个节点的父节点。将每个字符的频率作为节点的权值，初始化一棵包含N个叶子节点的树，其中N是不同字符的数量。
数据结构（二十） -- C语言版 -- 树 - 霍夫曼树（哈夫曼树、赫夫曼树、最优二叉树）、霍夫曼编码
青椒*^_^*凤爪爪的博客
07-04 5582
霍夫曼树也称为称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度 霍夫曼编码，又译为哈夫曼编码、赫夫曼编码，。是一种用于无损数据压缩的熵编码（权编码）算法。由美国计算机科学家大卫·霍夫曼（David Albert Huffman）在1952年发明。
哈夫曼树和哈夫曼编码的实现
09-06
文章使用C#编程语言实现了哈夫曼编码树和哈夫曼编码，并在VS2010下调试成功
c语言实现哈夫曼树的创建与中序遍历以及哈夫曼编码（附详细代码）
qq_62185081的博客
12-28 2102
次循环，每次先找输入的权值中最小的两个结点，把这两个结点的权值相加赋给一个新结点，并且这个新结点的左孩子是权值最小的结点，右孩子是权值第二小的结点；编码的思想是逆序编码，从叶子结点出发，向上回溯，如果该结点是回溯到上一个结点的左孩子，则在记录编码的数组里存。的结点，为了下次能正确寻找到剩下结点中权值最小的两个结点，每次循环要把找的权值最小的两个结点的双亲赋值不为。），每一次循环编码到根结点，把编码存在编码表中，然后开始编码下一个字符（叶子）个叶子结点，构建哈夫曼树，给出每个叶子结点对应编码的程序。
哈夫曼编码 Huffman code（C语言实现）
qq_62225979的博客
10-21 4436
对英文文本文件进行读取，统计字符出现的频率，并根据频率创建哈夫曼编码。将文本文件编码成编码文件，并能够实现从编码文件中读出原来的文本文件。
哈夫曼树与哈夫曼编码及代码实现
热门推荐
LH is programming hard
03-18 2万+
哈夫曼树与哈夫曼编码的理解 数据压缩 含义 通过对数据重新的编码，减少数据占用的空间存储；使用的时候再进行解压缩，恢复数据的原有特性。 类别 无损压缩——压缩过程没有数据丢失，解压得到原有数据特性。 有损压缩——压缩过程会丢失数据的部分信息，如压缩BMP位图为JPEG会导致精度损失 编码类型 定长编码方案：每个字符的编码长度一样，如ASCII码，128个字符，都是用8位二进制码表示的，最高位...
Huffman编码(二叉树应用).zip_Huffman树_huffman_哈夫曼编码_哈弗曼编码_赫夫曼编码
09-20
哈夫曼编码是一种高效的数据压缩方法，它基于一种特殊的二叉树——哈夫曼树（Huffman Tree），也称为最优二叉树。这种编码技术在信息传输和存储中有着广泛的应用，因为它能最大限度地减少数据的存储空间。下面将详细...
数据结构与算法--哈夫曼树/赫夫曼树 Python实现哈夫曼树 Python实现赫夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
storyfull
01-02 3501
哈夫曼树/赫夫曼树 Python实现赫夫曼树 Python实现哈夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
【树 - 哈夫曼树(Huffman Tree)】
最新发布
abclyq的博客
06-03 2216
哈夫曼又称最优二叉树, 是一种带权路径长度最短的二叉树。
ht.rar_哈夫曼树ht_赫夫曼编码HT
09-19
哈夫曼树（Huffman Tree），也称为最优二叉树，是数据压缩中的一种关键算法，由美国计算机科学家大卫·艾伦·哈夫曼在1952年提出。它是根据哈夫曼编码（Huffman Coding）理论构建的，主要用于实现变字长编码，以提高...
哈夫曼编码C语言程序
10-16
基于概率的哈夫曼编码C语言程序，能对txt文件中的诗句给予其对应的编码
c语言实现哈夫曼编码
01-01
c语言实现哈夫曼编码，并求平均码长 c语言实现哈夫曼编码，并求平均码长
C语言编码哈夫曼树
06-24
#include #include #include #include using namespace std; # define MaxN 100//初始设定的最大结点数 # define MaxC 1000//最大编码长度 # define ImpossibleWeight 10000//结点不可能达到的权值 # define n 26//字符集的个数 //-----------哈夫曼树的结点结构类型定义----------- typedef struct //定义哈夫曼树各结点 { int weight;//权值 int parent;//双亲结点下标 int lchild;//左孩子结点下标 int rchild;//右孩子结点下标 }HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树 typedef char**HuffmanCode;//动态分配数组存储哈夫曼编码表 //-------全局变量-------- HuffmanTree HT; HuffmanCode HC; int *w;//权值数组 //const int n=26;//字符集的个数 char *info;//字符值数组 int flag=0;//初始化标记 //********************************************************************** //初始化函数 //函数功能： 从终端读入字符集大小n , 以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中 //函数参数： //向量HT的前n个分量表示叶子结点，最后一个分量表示根结点，各字符的编码长度不等，所以按实际长度动态分配空间 void Select(HuffmanTree t,int i,int &s1,int &s2) { //s1为最小的两个值中序号最小的那个 int j; int k=ImpossibleWeight;//k的初值为不可能达到的最大权值 for(j=1;j<=i;j++) { if(t[j].weight<k&&t[j].parent==0) {k=t[j].weight; s1=j;} } t[s1].parent=1; k=ImpossibleWeight; for(j=1;j<=i;j++) { if(t[j].weight0），构造哈夫曼树HT，并求出n个字符的哈弗曼编码HC { int i,m,c,s1,s2,start,f; HuffmanTree p; char* cd; if(num<=1) return; m=2*num-1;//m为结点数，一棵有n个叶子结点的哈夫曼树共有2n-1个结点，可以存储在一个大小为2n-1的一维数组中 HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号单元未用 //--------初始化哈弗曼树------- for(p=HT+1,i=1;iweight=*w; p->parent=0; p->lchild=0; p->rchild=0; } for(i=num+1;iweight=0; p->parent=0; p->lchild=0; p->rchild=0; } //--------建哈夫曼树------------- for(i=num+1;i<=m;i++) { Select(HT,i-1,s1,s2);//在HT[1...i-1]选择parent为0且weight最小的两个结点，其序号分别为s1和s2 HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1; HT[i].rchild=s2;//左孩子权值小，右孩子权值大 HT[i].weight=HT[s1].weight+HT[s2].weight; } //-------从叶子到根逆向求每个字符的哈弗曼编码-------- HC=(HuffmanCode)malloc((num+1)*sizeof(char *));//指针数组:分配n个字符编码的头指针向量 cd=(char*)malloc(n*sizeof(char*));//分配求编码的工作空间 cd[n-1]='\0';//编码结束符 for(i=1;i<=n;i++)//逐个字符求哈弗曼编码 { start=n-1;//编码结束符位置 for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到跟逆向求哈弗曼编码 if(HT[f].lchild==c) cd[--start]='0';//判断是左孩子还是右孩子(左为0右为1) else cd[--start]='1'; HC[i]=(char*)malloc((num-start)*sizeof(char*));//按所需长度分配空间 int j,h; strcpy(HC[i],&cd[start]); } free(cd); } //****************初始化函数****************** void Initialization() { flag=1;//标记为已初始化 int i; w=(int*)malloc(n*sizeof(int));//为26个字符权值分配空间 info=(char*)malloc(n*sizeof(char));//为26个字符分配空间 ifstream infile("ABC.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i>info[i]; infile>>w[i]; } infile.close(); cout<<"读入字符成功！"<<endl; HuffmanCoding(HT,HC,w,n); //------------打印编码----------- cout<<"依次显示各个字符的值,权值或频度,编码如下"<<endl; cout<<"字符"<<setw(6)<<"权值"<<setw(11)<<"编码"<<endl; for(i=0;i<n;i++) { cout<<setw(3)<<info[i]; cout<<setw(6)<<w[i]<<setw(12)<<HC[i+1]<<endl; } //---------将建好的哈夫曼树写入文件------------ cout<<"下面将哈夫曼树写入文件"<<endl; ofstream outfile("hfmTree.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i<n;i++,w++) { outfile<<info[i]<<" "; outfile<<w[i]<<" "; outfile<<HC[i+1]<<" "; } outfile.close(); cout<<"已经将字符与对应的权值，编码写入根目录下文件hfmTree.txt"<<endl; } //*****************输入待编码字符函数************************* void Input() { char string[100]; ofstream outfile("ToBeTran.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } cout<<"请输入你想要编码的字符串(字符个数应小于100),以#结束"<>string; for(int i=0;string[i]!='\0';i++) { if(string[i]=='\0') break; outfile<<string[i]; } cout<<"获取报文成功"<<endl; outfile.close(); cout<<"------"<<"已经将报文存入根目录下的ToBeTran.txt文件"<<endl; } //******************编码函数**************** void Encoding() { int i,j; char*string; string=(char*)malloc(MaxN*sizeof(char)); cout<<"下面对根目录下的ToBeTran.txt文件中的字符进行编码"<<endl; ifstream infile("ToBeTran.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i>string[i]; } for(i=0;i<100;i++) if(string[i]!='#') cout<<string[i]; else break; infile.close(); ofstream outfile("CodeFile.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;string[i]!='#';i++) { for(j=0;j<n;j++) { if(string[i]==info[j]) outfile<<HC[j+1]; } } outfile<<'#'; outfile.close(); free(string); cout<<"编码完成------"; cout<<"编码已写入根目录下的文件CodeFile.txt中"<<endl; } //******************译码函数**************** void Decoding() { int j=0,i; char *code; code=(char*)malloc(MaxC*sizeof(char)); char*string; string=(char*)malloc(MaxN*sizeof(char)); cout<<"下面对根目录下的CodeFile.txt文件中的代码进行译码"<<endl; ifstream infile("CodeFile.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for( i=0;i>code[i]; if(code[i]!='#') { cout<<code[i]; } else break; } infile.close(); int m=2*n-1; for(i=0;code[i-1]!='#';i++) { if(HT[m].lchild==0) { string[j]=info[m-1]; j++; m=2*n-1; i--; } else if(code[i]=='1') m=HT[m].rchild; else if(code[i]=='0') m=HT[m].lchild; } string[j]='#'; ofstream outfile("TextFile.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } cout<<"的译码为------"<<endl; for( i=0;string[i]!='#';i++) { outfile<<string[i]; cout<<string[i]; } outfile<<'#'; outfile.close(); cout<<"------译码完成------"<<endl; cout<<"译码结果已写入根目录下的文件TextFile.txt中"<<endl; free(code); free(string); } //*************打印编码函数**************** void Code_printing() { int i; char *code; code=(char*)malloc(MaxC*sizeof(char)); cout<<"下面打印根目录下文件CodeFile.txt中的编码"<<endl; ifstream infile("CodeFile.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for( i=0;i>code[i]; if(code[i]!='#') cout<<code[i]; else break; } infile.close(); cout<<endl; ofstream outfile("CodePrin.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;code[i]!='#';i++) { outfile<<code[i]; } outfile.close(); free(code); cout<<"------打印结束------"<<endl; cout<<"该字符形式的编码文件已写入文件CodePrin.txt中"<<endl; } //*************打印哈夫曼树函数**************** int numb=0; void coprint(HuffmanTree start,HuffmanTree HT) //start=ht+26这是一个递归算法 { if(start!=HT) { ofstream outfile("TreePrint.txt",ios::out); if(!outfile) { cerr<<"打开失败"<rchild,HT); //递归先序遍历 cout<<setw(5*numb)<weight<rchild==0) cout<<info[start-HT-1]<<endl; outfile<weight; coprint(HT+start->lchild,HT); numb--; outfile.close(); } } void Tree_printing(HuffmanTree HT,int num) { HuffmanTree p; p=HT+2*num-1; //p=HT+26 cout<<"下面打印赫夫曼树"<<endl; coprint(p,HT); //p=HT+26 cout<<"打印工作结束"<<endl; } //*************主函数************************** int main() { char choice; do{ cout<<"************哈弗曼编/译码器系统***************"<<endl; cout<<"请选择您所需功能："<<endl; cout<<":初始化哈弗曼树"<<endl; cout<<":输入待编码字符串"<<endl; cout<<":利用已建好的哈夫曼树进行编码"<<endl; cout<<":利用已建好的哈夫曼树进行译码"<<endl; cout<<":打印代码文件"<<endl; cout<<":打印哈夫曼树"<<endl; cout<<":退出"<<endl; if(flag==0) { cout<<"请先初始化哈夫曼树,输入I"<<endl; cout<<""<>choice; switch(choice) { case 'I':Initialization();break; case 'W':Input();break; case 'E':Encoding();break; case 'D':Decoding();break; case 'P':Code_printing();break; case 'T':Tree_printing(HT,n);break; case 'Q':;break; default:cout<<"输入的命令出错，请重新输入！"<<endl; } }while(choice!='Q'); free(w); free(info); free(HT); free(HC); system("pause"); return 0; }
哈夫曼编码（C语言）
weixin_44783099的博客
06-18 2117
这里写自定义目录标题 #include<stdio.h> #include<string.h> #include<stdlib.h> #define maxval 10000.0 #define maxsize 100 //哈夫曼编码的最大位数 typedef struct { char ch; float weight; int lchild,rchild...
c语言哈夫曼编码代码,C语言哈夫曼编码代码
weixin_33586063的博客
05-24 728
C语言哈夫曼编码代码 #include #include #include int m,s1,s2; typedef struct { unsigned int weight; unsigned int parent,lchild,rchild; }HTNode,*HuffmanTree; //动态分配数组存储哈夫曼树 typedef char *HuffmanCode; //动态分配数组存储哈夫...
哈夫曼编码 （纯C语言）
weixin_63484669的博客
05-08 5991
吐了，一道题写一上午。
哈夫曼树与哈夫曼编码原理与代码
hello world 的博客
07-09 1607
哈夫曼编码是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码，是一种很好的文件压缩得到编码形式。 举一个例子：哈夫曼编码根据不同的字母（汉字）在文章中出现的频率不同构建不等长的编码，给出现频率最高的字最短的编码，给出现频率最低的字最长的编码，这样可以有效的节省空间，并且所有较短的编码都不是较长的编码的前缀，避免了二义性的问题。 哈夫曼编码需要通过哈夫
【数据结构--哈夫曼编码（C语言版）】
qq_61719813的博客
05-27 1万+
文章目录哈夫曼树及其应用哈夫曼树哈夫曼树的特点哈夫曼树的构造哈夫曼编码 哈夫曼树及其应用 哈夫曼树 介绍哈夫曼树前先介绍下面几个名词： 1. 结点的路径长度l 从根结点到该结点的路径上分支的数目，如下图结点a的l = 3。 2. 树的路径长度 树中所有叶子结点的路径长度之和，如下图该树的路径长度为2 + 3 + 3 + 2 + 2。 3. 结点的权w 给每一个结点赋予一个新的数值，称为这个结点的权。 4. 结点的带权路径长度l * w 从根结点到该结点之间的路径长度与该结点的权的乘积,下图结点a的带权路径长
哈夫曼树与哈夫曼编码：
Dwyane0030的博客
10-11 698
哈夫曼树与哈夫曼编码
构造赫夫曼树：实现哈夫曼编码的C++代码与分析
本文档主要探讨了哈夫曼树（Huffman Tree）在数据压缩领域的应用，特别是关于如何利用算法5.11和5.10来构建和编码的过程。哈夫曼树是一种特殊的二叉树，它是由一系列带权路径长度最短的节点组成的，常用于实现熵编码...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值