文件压缩-HuffMan压缩

最新推荐文章于 2021-03-23 18:07:30 发布
最新推荐文章于 2021-03-23 18:07:30 发布
阅读量1k 收藏 14
点赞数 2
分类专栏： C++ 文章标签： Huffman文件压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nameseven/article/details/98050731
版权
什么是HuffMan压缩：
简单来说就是利用Huffman树生成Huffman编码，对文件重复出现的字符进行记录，以减少出现次数。从而达到压缩文件的目的。
为什么HuffMan就能实现文件压缩呢？
数据在硬盘中的存储是有格式的，比如说字符就是char类型的，占了8个比特位，但是实际上有些字符可能根本就用不了8个比特位，因此就造成了空间的浪费。而huffman就是根据字符出现的次数重新建立存储规则，减少这些空间浪费。
什么是HuffMan树？

定义： Huffman树，又称最优二叉树，是加权路径长度最短的二叉树。
带权路径长度 = 节点的权值 * 当前节点距离根节点的路径长度
在这里插入图片描述

如何构建HuffMan树？

在这里插入图片描述

生成HuffMan编码

HuffMan树中左子树路径标记为0，右子树路径标记为1.从根节点到叶子结点的编码就是该字符的Huffman编码。
在这里插入图片描述

HuffMan文件压缩原理：

1.统计待压缩文件中每个字符出现的次数

  • 构建结构体，存放信息：字符，次数，编码
  • 遍历源文件，将每个字符的次数写入对应的结构体信息中

2.将字符出现的次数作为权值构建Huffman树

  • 普通的二叉树只能通过双亲节点找到子节点，但是在获取编码的时候需要通过叶子结点往根节点走，所有构建二叉树时，要有子节点指向双亲节点

3.通过Huffman树获取每个字符所对应的编码

  • 通过叶子结点找根节点的编码是逆序的，所以要使用reverse

4.向压缩文件中写入信息

  • 压缩文件中只保存压缩的文件内容是不够的，还要有一些记录源文件内容的信息
  • 第一行：存放源文件的后缀，因为在解压缩文件的时候需要后缀
  • 第二行：存放源文件字符，次数 的总行数
  • 第三行：存放字符和字符出现的次数–为了解压缩重建Huffman树
  • 剩余内容是压缩编码
    例如：源文件名为“1.txt”,存放“ABBBCCCCCDDDDDDD”
    在压缩文件中的模型为：
    在这里插入图片描述
解压缩：

1.获取后缀
2.获取字符以及对应的次数
3.重建Huffman树
4.解压压缩数据

  • 从压缩文件中读取一个字节ch
  • 从根节点开始，按照ch的8个比特位信息(代表字符的编码)从高到低遍历Huffman树：
    a.该比特位是0，取当前节点的左孩子，否则取右孩子
    b.一直遍历，直到遍历到叶子节点位置，该字符就被解析成功，讲解压出来的字符写入文件
    c.如果在遍历Huffman过程中，8个比特位已经比较完毕还没有到达叶子节点，就从第四步开始执行
    d.重复以上过程，直到所有的数据解析完毕
问题：

1.压缩汉字时候程序会崩溃，但是压缩字母程序就能正常运行？

  • 原因:创建存放信息的数据是char 类型的，类型大小是1字节(0~255),但是汉字都是占两个字节的，对应的char类型就会因为超过255而导致数组的下边变成负数，数组下边越界访问导致程序崩溃。
  • 解决方法：将存放信息的数据类型改成unsigned char 类型

2.解压大文件，只能解压缩一部分内容？

  • 原因：一般情况下，文件指针碰到EOF就表示到文件结尾了，因为EOF是 -1，也就是FF，所以只解压了一部分（解压到第一个FF就停止了）。
  • 解决方法：采用 feof()函数，多加一个判断即可，feof()函数就是判断文件末尾，而不仅仅是碰见EOF停止。

3.为什么压缩照片的时候会失败？

  • 原因：是因为 ‘\0’ 的问题,因为如果刚开始把（字节，次数）先写入 buf 中，再由 buf 通过 fwrite 函数写入文件中，一定会出现问题（可能出现 0 字节）。因为 fwrite 的第一个参数要求C格式的字符串，把 buf 转化为C格式的字符串，如果遇见 ‘\0’，就会停止，所以就会崩溃。
  • 解决方法：不要将字节写入 buf 中，而是通过 fputc 直接把字节写入文件中，然后再写入 buf 中，再将buf写入文件即可。
文件压缩的图解过程：

在这里插入图片描述

源码：
main.c

#include "HuffmanTree.hpp"
#include "FileCompressHuffman.h"

int main()
{
	//TestHuffman();

	FileCompressHuffmanM test;
	//test.CompressFile("文件压缩（原文件）.png");

	test.UnCompressFile("文件压缩.hzp");
	return 0;
}

huffmanTree.hpp

#pragma once
#include<iostream>
using namespace std;
#include<vector>
#include<queue>


template<class W>
struct HuffmanTreeNode   //定义哈弗曼树节点的类型
{
	HuffmanTreeNode(const W& weight)
		:_pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _weight(weight)
	{}

	HuffmanTreeNode<W>* _pLeft;
	HuffmanTreeNode<W>* _pRight;
	//用孩子双亲形式表示二叉树，方便从叶子结点找到根节点，从而对字符进行编码
	HuffmanTreeNode<W>* _pParent;

	W _weight;   //节点权值
};

template<class W>
struct Compare //用仿函数比较，变小堆
{
	typedef HuffmanTreeNode<W>* PNode;
	bool operator()(const PNode pLeft, const PNode pRight)
	{
		return pLeft->_weight > pRight->_weight;
	}
};


template<class W>
class HuffmanTree
{
	typedef HuffmanTreeNode<W> Node;
	typedef Node* PNode;
public:
	HuffmanTree()//构造函数，初始状态下为空树
		: _pRoot(nullptr)
	{}

	void CreatHuffmanTree(const std::vector<W>& v, const W& invalid)  //根据权值创建树，模板引用   vector在标准的命名空间中定义的
	{
 		if (v.empty())   //v是存放权值的数组
			return;
		//用所给的权值创建二叉树森林
		//std::priority_queue<PNode> q;    使用仿函数实现 小堆  比较器
		std::priority_queue<PNode,std::vector<PNode>,Compare<W>> q;//优先级队列 保存树，把地址放进去就好了，，但是默认是大堆，而我们需要的是小堆

		for (size_t i = 0; i < v.size(); ++i)
		{
			if (v[i] != invalid)  //过滤出现0次的字符,通过创建哈弗曼树多加上一个参数 来实现
			q.push(new Node(v[i]));  //用权值创建节点
		}
		while (q.size() > 1)  //当树不止一个时，把作为左右孩子
		{
			PNode pLeft = q.top();
			q.pop();

			PNode pRight = q.top();
			q.pop();

			PNode pParent = new Node(pLeft->_weight + pRight->_weight);
			
			pParent->_pLeft = pLeft;
			pLeft->_pParent = pParent;

			pParent->_pRight = pRight;
			pRight->_pParent = pParent;
			q.push(pParent);   //把两个子树生成的树放回队列中
		}
		_pRoot = q.top();   //哈夫曼树创建成功
	}

	PNode GetRoot()
	{
		return _pRoot;
	}

	~HuffmanTree()
	{
		_Destroy(_pRoot);   //销毁 哈夫曼树
	}

private:
	void _Destroy(PNode& pRoot)   //后序遍历进行销毁二叉树
	{
		if (pRoot)
		{
			_Destroy(pRoot->_pLeft);
			_Destroy(pRoot->_pRight);
			delete pRoot;
			pRoot = nullptr;
		}
	}

private:
	PNode _pRoot;
};


//void TestHuffman()
//{
//	std::vector<int> v{ 3,1,7,5 };
//	HuffmanTree<int> ht;
//	ht.CreatHuffmanTree(v);
//}

FileCompressHuffman.h

#pragma once
#include<string>
#include<iostream>
#include<vector>
#include "HuffmanTree.hpp"
using namespace std;

typedef unsigned char UCH;

//哈夫曼树中的字符信息，包括字符代表的字母，次数,编码
struct CharInfo
{
	//用构造函数初始化哈夫曼树中的字符
	CharInfo(size_t charCount = 0)
		: _charCount(charCount)
	{}

	//权值在结构体中，而结构体不能直接相加，所以要重载+
	CharInfo operator+(const CharInfo& info)  //字符出现的次数
	{
		return CharInfo(_charCount + info._charCount);
	}

	bool operator>(const CharInfo& info)
	{
		return _charCount > info._charCount;
	}

	bool operator!=(const CharInfo& info)const
	{
		return _charCount != info._charCount;
	}
	bool operator==(const CharInfo& info)const
	{
		return _charCount == info._charCount;
	}

	UCH _ch;
	size_t _charCount;
	std::string _strCode;
};

class FileCompressHuffmanM
{
public:
	FileCompressHuffmanM();
	void CompressFile(const std::string& strFilePath);  //const 保证原文件不会被修改
	void UnCompressFile(const std::string& strFilePath);//不加命名空间会如何？
	void WriteHead(FILE* fOut, const std::string& strFilePath);//头部信息：用来保存压缩文件的信息，包括后缀，字符出现的次数

private:
	void GetHuffmanCode(HuffmanTreeNode<CharInfo>* pRoot);
	void GetLine(FILE* fIn, std::string& strContent);
	std::vector<CharInfo> _charInfo;    //把编码保存在数组中,这个数组是个结构体类型的，字符信息

};

FileCompressHuffmanM.cpp

#pragma once
#include "FileCompressHuffman.h"
#include"HuffmanTree.hpp"
#include <iostream>
#include <assert.h>
using namespace std;

FileCompressHuffmanM::FileCompressHuffmanM() 
{
	_charInfo.resize(256);
	for (size_t i = 0; i < 256; ++i)
	{
		_charInfo[i]._ch = i;  //i是ch 的ASCII码
	}
}


void FileCompressHuffmanM::CompressFile(const std::string& strFilePath)
	{	 
        string MiddleName = strFilePath.substr(0, strFilePath.find('.'));// MiddleName是生成的压缩文件的名称
		//1.获取原文件中每个字符出现的次数
		FILE* fIn = fopen(strFilePath.c_str(), "rb");  //string 类 转换成char*类型
		if (fIn == nullptr)
		{
			cout << "文件打开失败" << endl;
			return;
		}

		UCH *pReadBuff = new UCH[1024];   //每次读取1024字节，即1M
		//long long CharCount[256] = { 0 };   //符号有可能出现很多次，所以出现次数用long long  类型表示
		
		//vector<CharInfo> charInfo(256);
		//初始化_ch

		while (1)
		{
			size_t rdSize = fread(pReadBuff, 1, 1024, fIn);//返回读到的元素个数
			if (0 == rdSize)
				break;
			for (size_t i = 0; i < rdSize; ++i)
			{
				//CharCount[pReadBuff[i]]++; //pReadBuff[i]表示第i个字节读到的内容，对应的ascii码作为数组CharCount的下标
				_charInfo[pReadBuff[i]]._charCount++;
			}
		}
		//2.以每个字符出现的次数作为权值构建哈夫曼树
		HuffmanTree<CharInfo> ht;   //类名 类型 实例化对象
		ht.CreatHuffmanTree(_charInfo,CharInfo(0));

		//3.根据哈弗曼树获取每个字符的编码
		GetHuffmanCode(ht.GetRoot());

		//4.根据每个字符的编码重新改写原文件
		//先打开一个文件，写入压缩信息
		MiddleName += ".hzp";
	
		FILE* fOut = fopen(MiddleName.c_str(), "wb");
		assert(fOut);

		WriteHead(fOut, strFilePath);
		UCH ch = 0;
		char bitCount = 0;
		fseek(fIn, 0, SEEK_SET);

		while (true)
		{
			size_t rdSize = fread(pReadBuff, 1, 1024, fIn);  //把buff中的编码写入压缩文件
			if (0 == rdSize)
				break;

			for (size_t i = 0; i < rdSize; ++i)
			{
				string& strCode = _charInfo[pReadBuff[i]]._strCode;
				// ch: 0000 0000
				// A:100
				// B:101
				for (size_t j = 0; j < strCode.size(); ++j)  //j小于  对应的字符的字符编码的长度
				{
					ch <<=1;
					if (strCode[j] == '1')   //ch初始值是0, ch代表一个字节,不是代表一个比特位，把这八个比特位填满就可以以往压缩文件中写入字节了
						ch |= 1;
					bitCount++;
					if (8 == bitCount)   //每满一个字节，就往压缩文件中写入一个字节
					{
						fputc(ch, fOut);
						bitCount = 0;
					}
				}
			}
		}
		//如果8个bit没有写满，还要把剩余的内容写入压缩文件
		if (bitCount >0 && bitCount < 8)   //大于0的原因是  ，如果8个比特位恰好写满，在上一步中会置0
		{
			ch <<= 8 - bitCount;
			fputc(ch , fOut);
		}

		delete[] pReadBuff;
		fclose(fIn);
		fclose(fOut);
 	}

void FileCompressHuffmanM::UnCompressFile(const std::string& strFilePath)
{
	//获得解压缩文件的名称
	string ResultName = strFilePath.substr(0,strFilePath.find('.'));

	//检测压缩文件的后缀格式
	string strPostFix = strFilePath.substr(strFilePath.rfind('.'));  //有两个参数，第二个默认结尾
	if (".hzp" != strPostFix )
	{
		cout << "压缩文件的格式有问题" << endl;
		return;
	}

	//获取解压缩的信息
	FILE* fIn = fopen(strFilePath.c_str(), "rb");     //fIn 是指向压缩信息 hzp文件   的指针
	if (fIn == nullptr)
	{
		cout << "压缩文件打开失败" << endl;
		return;
	}

	//获取原文件的后缀----读完压缩信息的第一行就行了，第一行保存的就是后缀
	strPostFix = "";
	GetLine(fIn, strPostFix);

	//获取总行数
	string strContent;
    GetLine(fIn, strContent);  //获取在遇到\n前的第一个内容，即行数，此时fIn 指向第一个\n
	size_t lineCount = atoi(strContent.c_str());

	//字符信息
	for (size_t i = 0; i < lineCount; ++i)
	{
		strContent = "";
		GetLine(fIn, strContent);  ??????     fIn此时不是指向的是\n么？
		if (strContent.empty())   //读取到换行符，如果不处理会直接退出，没有读取到后面的压缩内容
		{
			strContent += '\n';
			GetLine(fIn, strContent);
		}
		_charInfo[(UCH)strContent[0]]._charCount = atoi(strContent.c_str()+2); //获取到次数 获取的字符串是 A,1 字符A对应的是获取的字符串的下标为0 的元素 占据了两个字节，要偏移过去
	}              //strCont 中保存的是字符信息  如果是汉字  也有可能出现负数的情况，所以强转成无符号类型

	//还原哈夫曼树
	HuffmanTree<CharInfo> ht;
	ht.CreatHuffmanTree(_charInfo, CharInfo(0));

	//解压缩
	//string  strUNComFile = NameOfCompressFile;
	string strUNComFile = ResultName;

	strUNComFile += strPostFix;  //名字+后缀
	FILE* fOut = fopen(strUNComFile.c_str(), "wb");
	assert(fOut);

	char* pReadBuff = new char[1024];
	HuffmanTreeNode<CharInfo>* pCur = ht.GetRoot();
	char pos = 7;
	size_t SizeOfFile = pCur->_weight._charCount;


	while (true)
	{
		size_t  rdSize = fread(pReadBuff, 1, 1024, fIn); //从fIn文件中读取
		if (0 == rdSize)
		{
			break;
		}
		for (size_t i = 0; i < rdSize; ++i)
		{
			pos = 7;
			for (size_t j = 0; j < 8; ++j)  //处理当前的一个字节
			{
				//if ((pReadBuff[i] & (1 << pos)) == 1)//1朝右走
				if (pReadBuff[i] & (1 << pos))//1朝右走
					pCur = pCur->_pRight;
				else
					pCur = pCur->_pLeft;  //0朝左走
				if (nullptr == pCur->_pLeft && nullptr == pCur->_pRight)
				{
					fputc(pCur->_weight._ch, fOut);  //把这个字符写到fOut文件中
					pCur = ht.GetRoot();
					SizeOfFile--;
					if (0 == SizeOfFile)
					{
						break;
					}

				}
				pos--;
			}
		}
	}
	delete[] pReadBuff;
	fclose(fIn);
	fclose(fOut);
}

void FileCompressHuffmanM::GetHuffmanCode(HuffmanTreeNode<CharInfo>* pRoot)
{
	if (pRoot == nullptr)
	{
		return;
	}
	GetHuffmanCode(pRoot->_pLeft);
	GetHuffmanCode(pRoot->_pRight);
	if ((pRoot->_pLeft == nullptr) && (pRoot->_pRight == nullptr))
	{
		//找到叶子结点 ，保存叶子节点，并追寻双亲节点
		HuffmanTreeNode<CharInfo>* pCur = pRoot;  //以字符信息作为模板类型，pCur类型是个结构体
		HuffmanTreeNode<CharInfo>* pParent = pCur->_pParent;

		string& strCode = _charInfo[pCur->_weight._ch]._strCode; //?????数组是结构体类型，把编码保存在结构体的_strCode中
		while (pParent)            //以字符的ASCII作为数组的下标：   [叶子结点 中的权值 中的字符]
		{
			if (pCur == pParent->_pLeft)
			{
				strCode += '0';
			}
			else 
			{
				strCode += '1';
			}
			pCur = pParent;
			pParent = pCur->_pParent;
		}
		reverse(strCode.begin(), strCode.end());
	}
}

void FileCompressHuffmanM::WriteHead(FILE* fOut, const std::string& strFilePath)  //写入解压缩需要的信息
{
	string strHeadInfo;
	strHeadInfo = strFilePath.substr(strFilePath.rfind('.'));
	strHeadInfo += '\n';

	string strCharInfo;
	char szCount[32];
	size_t lineCount = 0;
	for (size_t i = 0; i < 256; ++i)
	{
		if (_charInfo[i]._charCount)
		{
			strCharInfo += _charInfo[i]._ch;   //把字符  和  次数放入  头信息中
			strCharInfo += ',';
			_itoa(_charInfo[i]._charCount, szCount, 10);
			strCharInfo += szCount;
			strCharInfo += '\n';
			lineCount++;
		}
	}
	_itoa(lineCount, szCount, 10);     //整型数据要转换成字符串
	strHeadInfo += szCount;
	strHeadInfo += '\n';

	strHeadInfo += strCharInfo;
	fwrite(strHeadInfo.c_str(), 1, strHeadInfo.size(), fOut);
}

void FileCompressHuffmanM::GetLine(FILE* fIn, std::string& strContent)
{
	while (!feof(fIn)) //指针没有在文件末尾，就读取一行
	{
		UCH ch = fgetc(fIn);
		if ('\n' == ch)
		{
			return;
		}
		strContent += ch;
	}
}
Name_seven
关注
专栏目录
huffman算法---文件压缩
Sunnylunch-blog
10-30 2304
利用huffman编码的思想对文件进行压缩，主要原理是通过huffman编码来重新表示字符，使得出现频率高的字符编码短，出现少的字符编码长。整体下来的话，所需的总的bit位是减少的。但是要注意当大部分字符出现的频率都差不多时，huffman压缩的压缩效率会很低。 一、利用huffman树对文件进行压缩主要分为以下两部分： 压缩： 1、统计字符出现的次数    因为文件的底层
Huffman编码文件压缩 - Huffman树的建立与编码
Jason ZHANG的博客
05-20 5388
【问题描述】 编写一程序采用Huffman编码对一个正文文件进行压缩。具体压缩方法如下： 1.    对正文文件中字符(换行字符'\'除外，不统计)按出现次数（即频率）进行统计 2.    依据字符频率生成相应的Huffman树（未出现的字符不生成） 3.    依据Huffman树生成相应字符的Huffman编码 4.    依据字符Huffman编码压缩文件（即按照Huffman编码
关于Huffman 压缩
starfish的专栏
03-22 2620
关于Huffman 压缩0.原理  Huffman编码是一种可变长编码方式，是由美国数学家David Huffman创立的，是二叉树的一种特殊转化形式。编码的原理是：将使用次数多的代码转换成长度较短的代码，而使用次数少的可以使用较长的编码，并且保持编码的唯一可解性。Huffman算法的最根本的原则是：累计的(字符的统计数字*字符的编码长度)为最小，也就是权值(字符的统计数字*字符的编码长度)的
基于huffman的文件压缩
iamubbTing的博客
11-27 870
算法思想： 1、哈夫曼数的建立 我使用类的方法建立哈夫曼数的 。首先建立一个节点类，包含了一个char字符，int型的权重，int型左右孩子和父节点的下标，以及char类型的code数组，里面存放的是0101的编码，最后还有这个code的长度，用于最后计算平均码长。 char data;//字符  charcode[50];//编码  intweight;//权重  int lchil
huffman(霍夫曼)算法-文件压缩解压
{丸の子}
08-05 202
用霍夫曼编码方式来压缩文件的源码，压缩率虽然不如ZIP高，但却是一种很好的保密方式 费话不多说，直接看附件
Huffman编码文件压缩
热门推荐
qq_45801887的博客
03-23 2万+
【问题描述】 编写一程序采用Huffman编码对一个正文文件进行压缩。具体压缩方法如下： 对正文文件中字符(换行字符’'除外，不统计)按出现次数（即频率）进行统计 依据字符频率生成相应的Huffman树（未出现的字符不生成） 依据Huffman树生成相应字符的Huffman编码 依据字符Huffman编码压缩文件（即按照Huffman编码依次输出源文件字符）。 说明： 只对文件中出现的字符生成Huffman，注意：一定不要处理\n，即不要为其生成Huffman码。 采用ASCII
北京工业大学--算法作业3--huffman编码对文本文件进行压缩与解压---Java
12-12
北京工业大学--算法作业3--huffman编码对文本文件进行压缩与解压---Java代码 设计并实现贪心算法，利用huffman编码对文本文件进行压缩与解压。 输入：一个文本文件 输出：压缩后的文件 算法过程： （1）统计文本...
用于文件压缩的huffman算法.zip_huff 压缩_huffman_vc huffman 压缩_压缩算法_文件压缩
09-23
在本压缩包中，"用于文件压缩的huffman算法"可能是包含具体实现细节的文档，如源代码、算法描述或步骤详解。"www.pudn.com.txt"可能是一个示例文本文件，用于演示哈夫曼压缩的效果。开发者使用VC++（Visual C++）这...
HuffmanTree文件压缩 - 快捷方式.zip
08-25
在这个“HuffmanTree文件压缩 - 快捷方式.zip”项目中，我们可以深入理解C++如何实现哈夫曼编码的过程。 哈夫曼编码的核心思想是：频繁出现的字符使用较短的编码，不频繁出现的字符使用较长的编码。这样，频繁出现...
Huffman-a-Extended-Huffman-coding.rar_huffman
09-22
哈夫曼编码（Huffman ...此外，可能还会介绍扩展哈夫曼编码在实际应用中的例子，如文件压缩、图像编码和数据传输优化等。通过深入理解哈夫曼编码和其扩展形式，我们可以更有效地进行数据压缩，提高存储和传输效率。
HUFFMAN 压缩
04-20
效率很低 过程很慢 大二做的 敬请原谅 至少所有文件都能压 1M以上文件就1MIN++
huffman 压缩
09-07
用Huffman编码对任何文件进行压缩/解压缩
huffman压缩
04-07
使用huffman编码对各种文档进行压缩,使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。
c++实现的文件压缩（Huffman）
09-14
包括Huffman树的生成，堆的建立，编码的形成，以及压缩与解压缩的实现。开发环境vs2015，用户在使用的时候为了防止环境的不同而造成的偏差，可新建相应文件复制即可。（基于c++模板）
数据结构课程设计——Huffman（简单压缩）
01-10
基于Huffman Coding简单压缩（放大），瞎搞课设，代码较丑。 发现有注释错了，找不到如何修改，不过百度云里的注释修改了 下面是源码链接。 链接：https://pan.baidu.com/s/1vTpE7TMjM8pqvm11jna7mQ 提取码：0zbb
哈夫曼文件压缩
qq_31032765的博客
03-07 275
用法： 压缩./ tar -y filename 解压缩 ./tar -j filename ==============编程思想================== 一、分析文件filename 按字符来分析 得出的结果，有哪些字符，每个字符出现的次数。 二、根据字符出现的次数，构建哈弗曼树。 得出字符的哈夫曼编码。
Huffman文件压缩
StriverLi的博客
05-06 600
Huffman文件压缩是一种经典的无损压缩方式，刚做完Huffman图片压缩实验不久，写一篇文章总结一下。所用环境为VS2013.原理1、所有文件都可以转化为一个一个的字节，例如Java中有字节流，就是通过字节的方式读写文件，C++中也是如此，这也就提供了统计文件中字节权重的方式。 2、可以通过统计到的字节的权重构建Huffman树，从而得到Huffman编码。 3、每个字节是八位二进制，而得到
Huffman压缩
慢慢来会比较快
04-06 2995
Huffman编码的Java实现，对数据的压缩和解压缩的过程做了分析和代码和代码实现，主要涉及到二叉树这种数据结构和一些数据处理方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值