Huffman编码与解码

最新推荐文章于 2021-05-05 18:58:56 发布
最新推荐文章于 2021-05-05 18:58:56 发布
阅读量452 收藏
点赞数
分类专栏： 编码 文章标签： 二叉树 编码 算法 数据结构 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mastic_29/article/details/60959426
版权


哈夫曼树又称为最优二叉树  哈夫曼编码是指一种可变长前缀码 即字符编码位数不统一 也无重复前缀  甚至有些情况下 哈夫曼编码被称为最优编码 于是着手简单的看了理论之后立即去实现  因为还要上课 总的时间大约花了我一天多时间结束 调完bug的一瞬间也是感觉世界真美好的 0-0


---C语言编程

---辅助栈手动实现

---重要函数及体现过程：

------------------------------ 统计字符概率（StatCodedChar ）

------------------------------ 按照概率排序（BubbleSort（冒泡））

------------------------------ 创建哈夫曼树（CreateHuffmanTree）

------------------------------ 遍历树并将编码元素放入编码表（LoopFOrderTree（非递归前序））

------------------------------ 编码（CreateHuffmancode）

------------------------------ 解码（HuffmanDecoder）

------------------------------ 释放哈夫曼树（FreeHuffmanTree）

------------------------------ 释放编码表（FreeCoderTable）

---编码输出到文件

---编码表输出到文件


---可改进：在解码时从文件中读取编码表到程序 从而达到编码与解码的完全分离使用（To Do）


编码表输出文件结果：

编码输出文件结果：



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

#define TRUE 1
#define FALSE 0
#define BOOL int
#define LEFT_CODE '0'
#define RIGHT_CODE '1'

typedef struct huffmannode
{
	BOOL IsSrcChar;
	char CodingNum;
	int Weight;
	char CodedChar;
	struct huffmannode *pLeftChlid;
	struct huffmannode *pRightChlid;
	struct huffmannode *pFather;
	struct huffmannode *pNext;
}HuffmanNode;

typedef struct codertablenode
{
	char CodedChar;
	char* CoderNum;
	int CoderPlacesNum;
}CoderTableNode;

typedef struct codelist
{
	char CodedNum;
	struct codelist *pNext;
}CodeList;
typedef struct stack
{
	HuffmanNode *tree;
	struct stack *pNext;
}Stack;

typedef struct MyStack
{
	Stack *stack;
	int count;
}Stack_Top;


CoderTableNode *pCoderTable = NULL;//编码表
int CoderTableLen = -1;

//当前字符是否在之前出现过 return 出现过返回1 没有出现过：0
int IsAppearBefore(char src_string[],char src_char,int char_appear_index)
{
	while(char_appear_index > 0)
	{
		if(src_char == src_string[--char_appear_index]) return 1;
	}
	return 0;
}

//统计字符概率
HuffmanNode* StatCodedChar(char src_string[],int len_src)
{
	int count;
	HuffmanNode *pHead = NULL;
	HuffmanNode *pTemp = NULL;
	//进行统计
	for(count = 0;count<len_src;count++)
	{
		if( !IsAppearBefore(src_string,src_string[count],count) )
		{
			pTemp = (HuffmanNode *)malloc(sizeof(HuffmanNode));
			
			pTemp->IsSrcChar = TRUE;
			pTemp->CodingNum = LEFT_CODE;
			pTemp->Weight = 1;
			pTemp->CodedChar = src_string[count];
			pTemp->pRightChlid = NULL;
			pTemp->pLeftChlid = NULL;
			pTemp->pFather = NULL;

			//用pNext指针来贯穿链表 头添加
			if(pHead != NULL)
			{
				pTemp->pNext = pHead;
				pHead->pFather = pTemp;
			}
			else
			{
				pTemp->pNext = NULL;
				pTemp->pFather = NULL;
			}
			pHead = pTemp;
		}
		else
		{
			pTemp = pHead;
			while(pTemp)
			{
				if(pTemp->CodedChar == src_string[count])
				{
					pTemp->Weight++;
					break;
				}
				pTemp = pTemp->pNext;
			}
		}
	}
	return pHead;
}

//冒泡排序：小->大
void BubbleSort(HuffmanNode **pHead)
{
	char temp_char;
	int temp_weigtht;
	HuffmanNode *pTemp = NULL;
	HuffmanNode *pLoopPoint = NULL;
	HuffmanNode *pLoopPoint_in = NULL;
	if(pHead == NULL)return ;

	pTemp = pLoopPoint = *pHead;
	while(pLoopPoint->pNext)
	{
		pLoopPoint_in = pLoopPoint;
		while(pLoopPoint_in->pNext)
		{
			if(pLoopPoint_in->Weight > pLoopPoint_in->pNext->Weight)
			{
				temp_char = pLoopPoint_in->CodedChar;
				temp_weigtht = pLoopPoint_in->Weight;
				pLoopPoint_in->Weight = pLoopPoint_in->pNext->Weight;
				pLoopPoint_in->CodedChar = pLoopPoint_in->pNext->CodedChar;
				pLoopPoint_in->pNext->Weight = temp_weigtht;
				pLoopPoint_in->pNext->CodedChar = temp_char;
			}
			pLoopPoint_in = pLoopPoint_in->pNext;
		}

		pLoopPoint = pLoopPoint->pNext;
	}
}

//对已排序的数据建造哈夫曼树
HuffmanNode* CreateHuffmanTree(HuffmanNode **pHead)
{
	int count;
	HuffmanNode *pTemp = NULL;
	HuffmanNode *HeadLastPoint = NULL;
	if(pHead == NULL)return NULL;

	while(*pHead != NULL)
	{
		pTemp =(HuffmanNode *)malloc(sizeof(HuffmanNode));
		pTemp->pLeftChlid = *pHead;
		pTemp->pLeftChlid->CodingNum = LEFT_CODE;//左孩子编码值为0
		pTemp->pLeftChlid->pFather = pTemp;//更新父亲
		pTemp->pRightChlid = (*pHead)->pNext;
		pTemp->pRightChlid->CodingNum = RIGHT_CODE;//右孩子编码值为1
		pTemp->pRightChlid->pFather = pTemp;//更新父亲
		pTemp->IsSrcChar = FALSE;
		pTemp->CodingNum = LEFT_CODE;
		pTemp->Weight = (*pHead)->Weight + (*pHead)->pNext->Weight;
		pTemp->CodedChar = -1;
		pTemp->pFather = NULL;
		pTemp->pNext = NULL;

		for(count = 0;count<2;count++)//断开原有结构 头指针后移
		{
			HeadLastPoint = (*pHead);
			(*pHead) = (*pHead)->pNext;
			if(HeadLastPoint->IsSrcChar == TRUE)
			{
				HeadLastPoint->pNext = NULL;
			}
		}

		if(*pHead == NULL)
			break;

		HeadLastPoint = *pHead;
		while(pTemp->Weight > HeadLastPoint->Weight && HeadLastPoint->pNext != NULL)
		{
			HeadLastPoint = HeadLastPoint->pNext;
		}

		if(HeadLastPoint == *pHead && HeadLastPoint->Weight >= pTemp->Weight)
		{
			pTemp->pNext = *pHead;
			(*pHead)->pFather = pTemp;
			*pHead = pTemp;
		}
		else
		{
			if(HeadLastPoint->pNext == NULL && HeadLastPoint->Weight < pTemp->Weight)
			{
				HeadLastPoint->pNext = pTemp;
				pTemp->pFather = HeadLastPoint;
				pTemp->pNext = NULL;
			}
			else
			{
				HeadLastPoint->pFather->pNext = pTemp;
				pTemp->pNext = HeadLastPoint;
				pTemp->pFather = HeadLastPoint->pFather;
				HeadLastPoint->pFather = pTemp;
			}
		}
	}
	return pTemp;
}

int GetCharCount(HuffmanNode *pHead)
{
	int CharCount = 0;
	HuffmanNode *ptemp = NULL;
	if(pHead == NULL)return -1;
	ptemp = pHead;
	while(ptemp)
	{
		CharCount++;
		ptemp = ptemp->pNext;
	}
	return CharCount;
}

//-------------------------------辅助栈-------------------------------------
void InitStack(Stack_Top** stacktop)
{
	*stacktop = (Stack_Top *)malloc(sizeof(Stack_Top));
	(*stacktop)->stack = NULL;
	(*stacktop)->count = 0;
}

void StackPush(Stack_Top *stacktop,HuffmanNode* val)
{
	Stack *pTemp = NULL;

	pTemp = (Stack *)malloc(sizeof(Stack));
	pTemp->tree = val;
	pTemp->pNext = NULL;
	if(stacktop->stack != NULL)
	{
		pTemp->pNext = stacktop->stack;
	}
	stacktop->stack = pTemp;
	stacktop->count++;
	return ;
}
HuffmanNode* StackPop(Stack_Top *stacktop)
{
	HuffmanNode *val = NULL;
	if(stacktop->stack == NULL)
		return NULL;
	else
	{
		Stack *pTemp = stacktop->stack;
		val = (stacktop->stack)->tree;
		stacktop->stack = stacktop->stack->pNext;
		free(pTemp);
		stacktop->count--;
		return val;
	}
}
//-----------------------------辅助栈---------------------------------------

//编码并加入表中
void CallBackCode(HuffmanNode *Node,CoderTableNode *CoderTable)
{
	int count_Places;
	int count;
	int count_Add;
	HuffmanNode *pTemp = NULL;
	CodeList *pHead = NULL;
	CodeList *pDel = NULL;
	CodeList *pTemp_CodeList = NULL;
	if(Node == NULL || CoderTable == NULL)return ;

	count_Places = 0;
	pTemp = Node;
	while(pTemp->pFather)
	{
		pTemp_CodeList = (CodeList*)malloc(sizeof(CodeList));
		pTemp_CodeList->CodedNum = pTemp->CodingNum;

		//头添加
		if(pHead == NULL)
		{
			pTemp_CodeList->pNext = NULL;
		}
		else
		{
			pTemp_CodeList->pNext = pHead;
		}
		pHead = pTemp_CodeList;
		count_Places++;
		pTemp = pTemp->pFather;
	}

	//放入编码表
	for(count = 0;count<CoderTableLen;count++)
	{
		if(pCoderTable[count].CodedChar == -1)
			break;
	}
	pCoderTable[count].CodedChar = Node->CodedChar;
	pCoderTable[count].CoderPlacesNum = count_Places;
	pCoderTable[count].CoderNum = (char *)malloc(sizeof(char)*count_Places);
	
	for(count_Add = 0;count_Add<count_Places;count_Add++)
	{
		pCoderTable[count].CoderNum[count_Add] = pHead->CodedNum;
		pDel = pHead;
		pHead = pHead->pNext;
		free(pDel);
		pDel = NULL;
	}
}

//非递归前序遍历
void LoopFOrderTree(HuffmanNode *tree)
{
	Stack_Top *stack = NULL;
	if(tree == NULL) return ;

	InitStack(&stack);
	while(1)
	{
		while(tree != NULL)
		{
			StackPush(stack,tree);
			tree = tree->pLeftChlid;
		}
		tree = StackPop(stack);

		if(tree == NULL) return ;

		if(tree->IsSrcChar == TRUE)
		{
			CallBackCode(tree,pCoderTable);//编码并加入表中
		}
		tree = tree->pRightChlid;
	}
}

//编码
void CreateHuffmancode(char src_string[],int len_src)
{
	int count;
	int count_in;
	int count_print;
	CoderTableNode *pTemp = NULL;
	FILE *pFile = NULL;
	if(src_string == NULL || len_src <= 0) return ;
	pTemp = pCoderTable;

	if(fopen_s(&pFile,"./Huffmancode.txt","w") != 0)return ;
	printf(">>>编码结果输出文件在此程序源文件同目录下 名为：Huffmancode.txt\n\n");//编码结果输出文件
	for(count = 0;count<len_src;count++)
	{	
		for(count_in = 0;count_in<CoderTableLen;count_in++)
		{	
			if(pTemp[count_in].CodedChar == src_string[count])
			{
				for(count_print = 0;count_print<pTemp[count_in].CoderPlacesNum;count_print++)
				{
					//printf("%c",pTemp[count_in].CoderNum[count_print]);
					fputc(pTemp[count_in].CoderNum[count_print],pFile);
				}
				break;
			}
		}
	}
	printf(">>>编码完成\n\n");
	fclose(pFile);
}

//输出编码表到文件
void PrintToFileOfCoderTable()
{
	int count;
	int count_in;
	FILE *pFile = NULL;
	if(pCoderTable == NULL || CoderTableLen <= 0)return ;

	if(fopen_s(&pFile,"./CoderTable.txt","w") != 0)return ;
	printf(">>>编码表结果输出文件在此程序源文件同目录下 名为：CoderTable.txt\n\n");//编码表结果输出文件
	for(count = 0;count<CoderTableLen;count++)
	{
		fputc(pCoderTable[count].CodedChar,pFile);
		fputc(':',pFile);
		for(count_in = 0;count_in<pCoderTable[count].CoderPlacesNum;count_in++)
		{
			fputc(pCoderTable[count].CoderNum[count_in],pFile);
		}
		fseek(pFile,4,SEEK_CUR);
	}
}

//递归释放哈夫曼树
void FreeHuffmanTree(HuffmanNode *pHunffmanTree)
{
	if(pHunffmanTree == NULL)return ;
	FreeHuffmanTree(pHunffmanTree->pLeftChlid);
	FreeHuffmanTree(pHunffmanTree->pRightChlid);
	free(pHunffmanTree);
	pHunffmanTree = NULL;
}

//释放编码表
void FreeCoderTable()
{
	int count;
	if(pCoderTable == NULL)return ;
	for(count = 0;count<CoderTableLen;count++)
	{
		free(pCoderTable[count].CoderNum);
		pCoderTable[count].CoderNum = NULL;
	}
	free(pCoderTable);
	pCoderTable = NULL;
}

//前期准备过程   编码
void HuffmanEncoder(char src_string[],int len_src)
{
	int CharCount;
	HuffmanNode *pHead = NULL;
	HuffmanNode *pHunffmanTree = NULL;

	if(src_string == NULL || len_src <= 0) return ;

	//准备过程
	pHead = StatCodedChar(src_string,len_src);//统计字符概率
	BubbleSort(&pHead);//按照概率排序
	CharCount = GetCharCount(pHead);//统计编码元素个数
	pHunffmanTree = CreateHuffmanTree(&pHead);//创建哈夫曼树

	pCoderTable = (CoderTableNode *)malloc(sizeof(CoderTableNode)*CharCount);//申请编码表
	CoderTableLen = CharCount;
	memset(pCoderTable,-1,sizeof(CoderTableNode)*CharCount);
	LoopFOrderTree(pHunffmanTree);//遍历树并放入编码表
	PrintToFileOfCoderTable();//编码表结果输出文件
	CreateHuffmancode(src_string,len_src);//编码过程
	FreeHuffmanTree(pHunffmanTree);//回收空间
}

//按照编码表匹配并打印 返回编码占位数
int SearchIsRightAndPrint(char huffmancodechar[],int LoopCount)
{
	int count;
	int count_in;
	int LoopCountTemp;
	if(huffmancodechar == NULL || LoopCount < 0)return -1;

	//查找匹配
	for(count = 0;count<CoderTableLen;count++)
	{
		LoopCountTemp = LoopCount;
		for(count_in = 0;count_in<pCoderTable[count].CoderPlacesNum;count_in++)
		{
			if(pCoderTable[count].CoderNum[count_in] == huffmancodechar[LoopCountTemp])
			{
				LoopCountTemp++;
			}
			else
			{
				break;
			}
		}
		//匹配成功 打印
		if(count_in == pCoderTable[count].CoderPlacesNum)
		{
			printf("%c",pCoderTable[count].CodedChar);
			return pCoderTable[count].CoderPlacesNum;
		}
	}
	return -1;
}

//解码
void HuffmanDecoder(char *filename)
{
	int filesize;
	int SearchResult;
	int LoopCount;
	FILE *pFile = NULL;
	char *huffmancodechar = NULL;
	if(fopen_s(&pFile,filename,"r") != 0)return ;

	//得到编码
	fseek(pFile,0,SEEK_END);//偏移至文件尾
	filesize = ftell(pFile);//得到文件大小
	rewind(pFile);//重新指向文件开头
	huffmancodechar = (char *)malloc(sizeof(char)*filesize);
	memset(huffmancodechar,0,sizeof(char)*filesize);

	if( fgets(huffmancodechar,filesize+1,pFile) == NULL)
	{
		return ;
		//printf("%s",huffmancodechar);
	}
	fclose(pFile);

	//解码
	LoopCount = 0;
	while(LoopCount <= filesize)
	{
		SearchResult = SearchIsRightAndPrint(huffmancodechar,LoopCount);//按照编码表匹配并打印
		if(SearchResult == -1)
			break ;
		else
			LoopCount+=SearchResult;
	}
	printf("\n");
	FreeCoderTable();//释放编码表
}
int main()
{
	char arr[] = "fdg;d;gfherwrewrwqersddfshghdsfgghjdsfgfhasfashhsdtgsdghhhfghdhdfyuuyuoipasopuyiuhhfyuareryewgrelgeryuthreunrblerbytbyltjbysbhbewtbhetbhbtwebrltberwhtberlktbertbhewrlbtlhewrbtlethgsdfhgkdsfhglghsdfhgjldsfhgjhdsfglhdsflghdfhgjldsfhgjfdhgldshgdsflghdsfhgdsghjdhgdfhglkdffsgdsgsdgfgsgfhfdhdf";
	HuffmanEncoder(arr,strlen(arr));
	HuffmanDecoder("./Huffmancode.txt");
	system("pause");
	return 0;
}
Mastic_29
关注
专栏目录
Huffman编码和解码
qq_40579095的博客
09-12 758
头文件 #ifndef TEST_H_INCLUDED #define TEST_H_INCLUDED typedef short int Bool; class HuffmanTreeNode{ private: float m_weight; short int m_parent, m_lchild, m_rchild; public: void SetW...
Huffman编码与解码 （Huffman编码、二叉树）
kaka0209的博客
03-12 2829
Huffman编码与解码 [问题描述] 对一篇不少于2000字符的英文文章（source.txt），统计各字符出现的次数，实现Huffman编码(code.dat)，以及对编码结果的解码(recode.txt)。 [基本要求] （1） 输出每个字符出现的次数和编码,并存储文件(Huffman.txt)。 （2） 在Huffman编码后，英文文章编码结果保存到文件中(code.dat)，编码结果必须...
huffman编码与解码
虾米哥 专栏
03-13 1619
#include #include #include #define M 1000#define N 128typedef struct node{ int weight; struct node *lchild , *rchild , *parent ; struct node *next;}HuffmanNode , *HuffmanTree;
数据结构huffman编码与解码实现文件的压缩与解压.pdf
最新发布
11-12
《数据结构：Huffman编码与解码实现文件的压缩与解压》 在信息技术领域，文件压缩是一种常见的数据处理技术，旨在减少文件占用的存储空间，同时保持数据的完整性和可恢复性。Huffman编码是一种基于频率的无损数据...
数据结构huffman编码与解码实现文件的压缩与解压.docx
11-12
在文件压缩与解压中，Huffman编码扮演着关键角色。 1. **目标与问题分析** - **目标任务**：设计并实现一个基于Huffman编码的文件压缩和解压缩系统。该系统应能接受任何类型的文件，将其压缩成更小的体积，并能在...
哈夫曼编码与解码
05-29
文档提供构造哈夫曼编码与解码，构造哈夫曼树。
Huffman树编码解码
12-13
1、 采用队列的顺序存储结构；　　　 2、用菜单的形式完成队列的建立、出队、入队等基本操作； 3、采用栈的链式存储结构；　　　 4、用菜单的形式完成栈的出栈、入栈等基本操作；
哈夫曼编码和解码
m0_51384638的博客
05-05 5813
在前一文中，介绍了根据权值进行哈夫曼树的构建（https://blog.csdn.net/m0_51384638/article/details/116278540）。本文，将对传入的字符串进行编码，得出一个哈夫曼编码表，并根据编码表解码，得到原来的数据。 要实现对字符串进行哈夫曼编码和解码，我认为需要解决的问题如下： 1如何统计频率.每一个字符如何与它的权值建立一一对应的关系。 2.搭建哈夫曼树之后，如何得到每一个字符的哈夫曼编码。 3.根据哈夫曼编码表，如何解码得到原来的字符串。 现在，问题依次来解决
哈夫曼（Huffman）编码与解码
TJUT_LJX的博客
05-12 5449
题目描述利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码。对于双工信道，每端都需要一个完整的编码/译码系统。试为这样的信息收发站写一个哈夫曼的编/译码系统。 一个完整的系统具有以下几种操作： 0：初始化(Initialization)。从终端读入字符集大小n，以及n个字符和n个
数据压缩三-Huffman编码与解码
yejia1280的博客
05-02 661
一.实验原理 1.Huffman编码 哈夫曼编码(Huffman Coding)，又称霍夫曼编码,是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，概率大的符号码长短，概率小的符号码长长，是一种无失真编码。有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。1.哈夫曼编码的方法：
Huffman编码解码
riba2534的博客
04-20 2094
转载自：http://blog.csdn.net/q547550831/article/details/51589278 Huffman编码解码 霍夫曼(Huffman)编码问题也就是最优编码问题，通过比较权值逐步构建一颗Huffman树，再由Huffman树进行编码、解码。 其步骤是先构建一个包含所有节点的线性表，每次选取最小权值的两个节点，生成一个父亲节点，该父亲节点
基于JAVA实现的Huffman哈夫曼树编码与解码
08-01 438
1 概述给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种...
使用C语言实现Huffman编码与解码
"Huffman编码和解码的C语言实现" Huffman编码是一种高效的数据无损压缩技术，通过创建特殊的二叉树（Huffman树）来为数据分配不同的二进制编码，频繁出现的字符被赋予较短的编码，而较少出现的字符则使用较长的编码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值