C++实现哈夫曼编码

最新推荐文章于 2024-03-09 17:33:17 发布
最新推荐文章于 2024-03-09 17:33:17 发布
阅读量6.7k 收藏 142
点赞数 18
分类专栏： 数据结构 文章标签： c++ 霍夫曼树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHuRui/article/details/124985516
版权

文章目录

代码转自涂然哥，只做整理和略微修改

思路

1.输入一个字符串后统计每个字符出现的次数（频率）
2.接下来按照规则构造一棵哈夫曼树
3.然后01编码（即给每个字符赋予一个01组成的字符串）
4.将我们输入的字符串按照编码规则生成01字符串
5.解码：将字符串的01编码按照规则还原并输出

相关功能实现

结构体的定义

/*记录每个字符出现的次数*/
typedef struct wordcnt
{
    char ch;
    int cnt=0;
}Count;

/*整个字符串的字符构成*/
typedef struct NumCount
{
    Count count[MaxSize];
    int length=0;
}NumCount;

/*核心哈夫曼树*/
typedef struct HTree
{
    char data;
    int weight;
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;

/*树的节点的编码*/
typedef struct HCode
{
    char data;
    char* str;
}*HuffmanCode;

函数申明

void ReadData(char *source);  // 读入文件 
void WordCount(char *data,NumCount *paraCnt); // 统计次数 
void Show(NumCount *paraCnt);   // 展示次数 
void CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray);  // 创建哈夫曼树 
void select(HuffmanTree HT,int top,int *s1,int *s2);  // 选择权重最小的两个节点 
void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length);  // 创建哈夫曼编码 
void Encode(char *data,HuffmanCode HC,int length);  // 将读入的文件编码，写到txt文件 
void Decode(HuffmanTree HT,int length);  //读入编码文件，解码

读入文件

将我们需要压缩的字符串从文件读入到数组中

void ReadData(char *source)
{
	//打开文件读入数据 
	ifstream infile;
	infile.open("in.txt");
	cout<<"Reading..."<<endl;
	cout<<"the input file is:"<<endl;
	infile.getline(source,MaxSize);
	cout<<source<<endl;
	infile.close();
	cout<<endl;
}

统计次数

统计读入的字符串中每个字符分别出现多少次

void WordCount(char* data,NumCount* paraCnt)
{
    int flag;
    int len=strlen(data);
    for(int i=0;i<len;++i)
    {
        flag=0;
        for(int j=0;j<paraCnt->length;++j)
        {
            if(data[i]==paraCnt->count[j].ch)
            {
                ++paraCnt->count[j].cnt;
                flag=1;
                break;
            }
        }
        if(flag==0)
        {
            paraCnt->count[paraCnt->length].ch=data[i];
            ++paraCnt->count[paraCnt->length].cnt;
            ++paraCnt->length;
        }
    }
}

展示次数

将每个字符及其出现的次数输出

void Show(NumCount* paraCnt)
{
	cout<<"the length is "<<paraCnt->length<<endl;
	for(int i = 0;i < paraCnt->length;++i)
	{
		cout<<"The character "<<paraCnt->count[i].ch<<"  appears  "<<paraCnt->count[i].cnt<<endl;
	}
	cout<<endl;
}

创建哈夫曼树

核心哈夫曼树的构造，此处会多次调用select函数找到权重最小的两个节点

void CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray)
{
    if(length<=1)
    printf("ERROR!!!\r\n");

	int s1,s2;
	int m = length*2-1;  // 没有度为1的节点，则总结点是2*叶子节点数-1个 
	HT = new HTNode[m+1];
	for(int i = 1;i <= m;++i)  // 初始化 
	{
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
	}
	
	for(int i = 1;i <= length;++i) 
	{
		HT[i].data = cntarray.count[i-1].ch;
		HT[i].weight = cntarray.count[i-1].cnt;
	}
	
	for(int i = length + 1;i <= m;++i)
	{
		select(HT,i-1,&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;  // 得到一个新节点 
	}
}

选择权重最小的两个节点

void select(HuffmanTree HT,int top,int* s1,int* s2)
{
	int min = INT_MAX;
	for(int i = 1;i <= top;++i)  // 选择没有双亲的节点中，权重最小的节点 
	{
		if(HT[i].weight < min && HT[i].parent == 0)
		{
			min = HT[i].weight;
			*s1 = i;
		}
	}
	
	min = INT_MAX;
	for(int i = 1;i <= top;++i)  // 选择没有双亲的节点中，权重次小的节点 
	{
		if(HT[i].weight < min && i != *s1 && HT[i].parent == 0)
		{
			min = HT[i].weight;
			*s2 = i;
		}
	}
}

创建哈夫曼编码

将哈夫曼树中的每一个非空节点生成一个对应的01编码

void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length)
{
	HC = new HCode[length+1];
	char *cd = new char[length];  // 存储编码的临时空间 
	cd[length-1] = '\0';  // 方便之后调用strcpy函数 
	int c,f,start;
	for(int i = 1;i <= length;++i)
	{
		start = length-1;  // start表示编码在临时空间内的起始下标，由于是从叶子节点回溯，所以是从最后开始 
		c = i;
		f = HT[c].parent;
		while(f != 0)
		{
			--start;  // 由于是回溯，所以从临时空间的最后往回计 
			if(HT[f].lchild == c)
				cd[start] = '0';
			else 
				cd[start] = '1';
			c = f;
			f = HT[c].parent;
		}
		HC[i].str = new char[length-start];  // 最后，实际使用的编码空间大小是length-start 
		HC[i].data = HT[i].data;
		strcpy(HC[i].str,&cd[start]);  // 从实际起始地址开始，拷贝到编码结构中 
	}
	delete[] cd;
}

将读入的文件编码，写到txt文件中

void Encode(char* data,HuffmanCode HC,int length)
{
	ofstream outfile;
	outfile.open("code.txt");
	for(int i = 0;i < strlen(data);++i)  // 依次读入数据，查找对应的编码，写入编码文件 
	{
		for(int j = 1;j <= length;++j)
		{
			if(data[i] == HC[j].data)
			{
				outfile<<HC[j].str;
			}
		}
	}
	outfile.close();
	cout<<"the code txt has been written"<<endl;
	cout<<endl;
}

读入编码文件，解码

void Decode(HuffmanTree HT,int length)
{
	char codetxt[MaxSize*length];
	ifstream infile;
	infile.open("code.txt");
	infile.getline(codetxt,MaxSize*length);
	infile.close();
	
	ofstream outfile;
   	outfile.open("out.txt");
	
	int root = 2*length-1;  // 从根节点开始遍历 
	for(int i = 0;i < strlen(codetxt);++i)
	{
		if(codetxt[i] == '0') root = HT[root].lchild;  //为0表示向左遍历 
		else if(codetxt[i] == '1') root = HT[root].rchild; //为1表示向右遍历 
		if(HT[root].lchild == 0 && HT[root].rchild == 0)  // 如果已经是叶子节点，输出到输出文件中，然后重新回到根节点 
		{
			outfile<<HT[root].data;
			root = 2*length-1;
		}
	}
	outfile.close();
	cout<<"the output txt has been written"<<endl;
	cout<<endl;
}

完整代码实现

#include <iostream>
#include <fstream>
#include <string.h>
using namespace std; 

#define MaxSize 1024

typedef struct wordcnt
{
    char ch;
    int cnt=0;
}Count;

typedef struct NumCount
{
    Count count[MaxSize];
    int length=0;
}NumCount;

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

typedef struct HCode
{
    char data;
    char* str;
}*HuffmanCode;

void ReadData(char *source);  // 读入文件 
void WordCount(char *data,NumCount *paraCnt); // 统计次数 
void Show(NumCount *paraCnt);   // 展示次数 
void CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray);  // 创建哈夫曼树 
void select(HuffmanTree HT,int top,int *s1,int *s2);  // 选择权重最小的两个节点 
void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length);  // 创建哈夫曼编码 
void Encode(char *data,HuffmanCode HC,int length);  // 将读入的文件编码，写到txt文件 
void Decode(HuffmanTree HT,int length);  //读入编码文件，解码 

int main(int argc, char** argv) {
	char data[MaxSize];  
	NumCount Cntarray;
	ReadData(data);  // 读入数据 
	WordCount(data,&Cntarray);  // 统计次数 
	Show(&Cntarray); //可以查看每个单词出现的对应次数 
	HuffmanTree tree;
	CreateHuffmanTree(tree,Cntarray.length,Cntarray);  // 建树 
	HuffmanCode code;  
	CreateHuffmanCode(tree,code,Cntarray.length);  // 创建编码 
	Encode(data,code,Cntarray.length);  // 生成编码文件 
	Decode(tree,Cntarray.length);  // 解码 
	cout<<"Please view the generated TXT file to check the result"<<endl; 
	return 0;
}

void ReadData(char *source)
{
	//打开文件读入数据 
	ifstream infile;
	infile.open("in.txt");
	cout<<"Reading..."<<endl;
	cout<<"the input file is:"<<endl;
	infile.getline(source,MaxSize);
	cout<<source<<endl;
	infile.close();
	cout<<endl;
}

void WordCount(char *data,NumCount *paraCnt)
{
	int flag;// 标识是否已经记录 
	int len = strlen(data);
	for(int i = 0;i < len;++i)
	{
		flag = 0;
		for(int j = 0;j < paraCnt->length;++j)
		{
			if(paraCnt->count[j].ch == data[i]) // 若已有记录，直接++ 
			{
				++paraCnt->count[j].cnt;
				flag = 1;
				break;
			}
			
		}
		if(!flag) // 没有记录，则新增 
		{
			paraCnt->count[paraCnt->length].ch = data[i];
			++paraCnt->count[paraCnt->length].cnt;
			++paraCnt->length;
		}
	}
}

void Show(NumCount* paraCnt)
{
	cout<<"the length is "<<paraCnt->length<<endl;
	for(int i = 0;i < paraCnt->length;++i)
	{
		cout<<"The character "<<paraCnt->count[i].ch<<"  appears  "<<paraCnt->count[i].cnt<<endl;
	}
	cout<<endl;
}

void CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray)
{
    if(length<=1)
    printf("ERROR!!!\r\n");

	int s1,s2;
	int m = length*2-1;  // 没有度为1的节点，则总结点是2*叶子节点数-1个 
	HT = new HTNode[m+1];
	for(int i = 1;i <= m;++i)  // 初始化 
	{
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
	}
	
	for(int i = 1;i <= length;++i) 
	{
		HT[i].data = cntarray.count[i-1].ch;
		HT[i].weight = cntarray.count[i-1].cnt;
	}
	
	for(int i = length + 1;i <= m;++i)
	{
		select(HT,i-1,&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;  // 得到一个新节点 
	}
}

void select(HuffmanTree HT,int top,int* s1,int* s2)
{
	int min = INT_MAX;
	for(int i = 1;i <= top;++i)  // 选择没有双亲的节点中，权重最小的节点 
	{
		if(HT[i].weight < min && HT[i].parent == 0)
		{
			min = HT[i].weight;
			*s1 = i;
		}
	}
	
	min = INT_MAX;
	for(int i = 1;i <= top;++i)  // 选择没有双亲的节点中，权重次小的节点 
	{
		if(HT[i].weight < min && i != *s1 && HT[i].parent == 0)
		{
			min = HT[i].weight;
			*s2 = i;
		}
	}
}

void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length)
{
	HC = new HCode[length+1];
	char *cd = new char[length];  // 存储编码的临时空间 
	cd[length-1] = '\0';  // 方便之后调用strcpy函数 
	int c,f,start;
	for(int i = 1;i <= length;++i)
	{
		start = length-1;  // start表示编码在临时空间内的起始下标，由于是从叶子节点回溯，所以是从最后开始 
		c = i;
		f = HT[c].parent;
		while(f != 0)
		{
			--start;  // 由于是回溯，所以从临时空间的最后往回计 
			if(HT[f].lchild == c)
				cd[start] = '0';
			else 
				cd[start] = '1';
			c = f;
			f = HT[c].parent;
		}
		HC[i].str = new char[length-start];  // 最后，实际使用的编码空间大小是length-start 
		HC[i].data = HT[i].data;
		strcpy(HC[i].str,&cd[start]);  // 从实际起始地址开始，拷贝到编码结构中 
	}
	delete[] cd;
}

void Encode(char* data,HuffmanCode HC,int length)
{
	ofstream outfile;
	outfile.open("code.txt");
	for(int i = 0;i < strlen(data);++i)  // 依次读入数据，查找对应的编码，写入编码文件 
	{
		for(int j = 1;j <= length;++j)
		{
			if(data[i] == HC[j].data)
			{
				outfile<<HC[j].str;
			}
		}
	}
	outfile.close();
	cout<<"the code txt has been written"<<endl;
	cout<<endl;
}

void Decode(HuffmanTree HT,int length)
{
	char codetxt[MaxSize*length];
	ifstream infile;
	infile.open("code.txt");
	infile.getline(codetxt,MaxSize*length);
	infile.close();
	
	ofstream outfile;
   	outfile.open("out.txt");
	
	int root = 2*length-1;  // 从根节点开始遍历 
	for(int i = 0;i < strlen(codetxt);++i)
	{
		if(codetxt[i] == '0') root = HT[root].lchild;  //为0表示向左遍历 
		else if(codetxt[i] == '1') root = HT[root].rchild; //为1表示向右遍历 
		if(HT[root].lchild == 0 && HT[root].rchild == 0)  // 如果已经是叶子节点，输出到输出文件中，然后重新回到根节点 
		{
			outfile<<HT[root].data;
			root = 2*length-1;
		}
	}
	outfile.close();
	cout<<"the output txt has been written"<<endl;
	cout<<endl;
}

测试样例

输入：in.txt
In my lifetime, I will be a sincere person and never give up my love and dedication to life. I will live an infinite life in a limited time and space.
输出
the input file is:
In my lifetime, I will be a sincere person and never give up my love and dedication to life. I will live an infinite life in a limited time and space.
the length is 24
The character I appears 3
The character n appears 12
The character appears 30
The character m appears 5
The character y appears 2
The character l appears 10
The character i appears 18
The character f appears 4
The character e appears 18
The character t appears 6
The character , appears 1
The character w appears 2
The character b appears 1
The character a appears 8
The character s appears 3
The character c appears 3
The character r appears 3
The character p appears 3
The character o appears 4
The character d appears 6
The character v appears 4
The character g appears 1
The character u appears 1
The character . appears 2
the code txt has been written
the output txt has been written
Please view the generated TXT file to check the result
hafumantree

ALuoJi
关注
  • 18
    点赞
  • 踩
  • 142
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
哈夫曼编码 C++
02-27
哈夫曼编码DEMO 输入一段字符串以EOF（Ctrl + Z）结束 输出每个字符的频率 输出每个哈夫曼编码对应的字符 输出编码结果 输出解码结果 运行命令 huffman < in.txt > out.txt
哈夫曼（Huffman）编码问题（C++）
weixin_44023658的博客
05-05 1万+
一、题目描述 哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。一个包含100,000个字符的文件，各字符出现频率不同，如下表所示： 有多种方式表示文件中的信息，若用0,1码表示字符的方法，即每个字符用唯一的一个0,1串表示。若采用定长编码表示，则需要3位表示一个字符，整...
C++实现哈夫曼编码、解码
最新发布
qq_45285738的博客
03-09 323
第二部分打印出来的是，测试数据 A B C D E F G 的对应编码，这里可以自行扩充。第一部分打印出来的是 哈夫曼树 的结构。第三部分是用于测试的解码结果。
哈夫曼编码C++实现
03-25
哈夫曼编码是广泛用于数据文件压缩的十分有效的编码方式，其压缩率通常在20%—90%之间。哈夫曼编码算法是通过使用字符在文件中出现的频率表来构造最优前缀码的贪心算法。所谓前缀码，即是任一字符的编码都不是其他字符编码的前缀。哈夫曼算法以自底向上的方式，将各字符（n个）存在叶节点中，通过n-1次合并，来产生表示最优前缀码的完全二叉树。
哈夫曼编码C++实现 源文件
06-21
哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。
哈夫曼编码c++ 代码
10-04
数据结构课程设计哈夫曼的代码，vs2010 以上的直接打开可以运行； 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。
C++ 哈夫曼编码
ChanJose的博客
03-13 2万+
1.哈夫曼编码的结点类： struct HuffmanNode { int weight; // 权重，出现的次数或者频率 char ch; // 存储符号 string code; // 存储该符号对应的编码 int leftChild, rightChild, parent; // 左、右孩子，父结点 }; 2.思路： （1）统计输入的字符串中不同字...
哈夫曼编码（C++实现）
热门推荐
Edison's 小宇宙
08-27 2万+
哈夫曼树是用来创建哈夫曼编码的。哈夫曼编码是一种可以用于数据压缩的编码方式，哈夫曼编码的构造过程需要用到哈夫曼树。
哈夫曼编码C++
2301_76221972的博客
02-14 2796
哈夫曼编码c++
C++实现哈夫曼编码问题
11-05
C++实现哈夫曼编码问题
基于c++实现哈夫曼编码
06-17
基于c++实现哈夫曼编码
《算法导论》实验四：哈夫曼（Huffman）编码问题（C++实现）
allin_allin的恋爱小屋
12-14 1万+
哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。
[C、C++]数据结构：哈夫曼树 & 字母表的哈夫曼编码
weixin_74338356的博客
10-07 386
哈夫曼编码得到的一定是前缀编码。每一个元素作为叶子结点，把频度作为权值。1.每次选择2个权值最低的结点（树）作为兄弟，形成新的树，根节点为两结点权值之和。往往结点的权重用其data的出现频率代替，为了让传递的二进制信息尽可能小。哈夫曼树（最优二叉树）：含有某n个叶子结点的，带权路径长度最低的二叉树。前缀编码：不存在某个元素的编码是另一个元素的前缀的情况。结点的权、结点的带权路径长度，树的带权路径长度。左侧是固定长度编码，右侧是可变长度编码。3.重复前两步直到剩下一棵树。哈夫曼树的结点数为n-1。
哈夫曼树与哈夫曼编码（c++实现）
H.A.N.的博客
11-30 6268
哈夫曼树与哈夫曼编码一、字符的机内表示二、 哈夫曼树的概念三、 哈夫曼树的理论实现四、 哈夫曼树的代码实现理论设计代码实现代码总结和测试 一、字符的机内表示 在计算机中每个西文字符是用一个编码表示，大多数编码系统都采用等长编码，如ASCII编码 例如在某段文本中用到了下列字符，括号中是它们出现的频率：a(10), e(15), i(12), s(3), t(4), 空格(13), 换行(1)。如采用定长编码，7个不同的字符至少要用3位编码。 下图给出了一种编码对应方法： 上述编码形式可以对应下面的二叉树，
C++哈夫曼树+哈夫曼编码的实现（双完整版）
不负AC不负卿的博客
06-01 1万+
C++版全网最全、详解、引导思考的哈夫曼树和哈夫曼编码讲解，剖析了关键代码，适合收藏~
c++实现哈夫曼编码
10-07
要在C语言中实现哈夫曼编码，你可以按照以下步骤进行操作： 1. 创建数据结构来表示哈夫曼树和哈夫曼编码表。 2. 统计待编码的数据中每个字符的频率，并根据频率构建哈夫曼树。 3. 根据哈夫曼树生成哈夫曼编码表，即每个字符对应的二进制编码。 4. 使用哈夫曼编码表将原始数据编码为二进制数据。 5. 将二进制数据写入输出文件。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ALuoJi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值