哈夫曼树压缩文件
在这我创造了三个头文件pch.h，compress.h，huffman.h，在这其中compress.h和huffman.h里面包含的是一些函数的和结构体的定义，而pch.h是我visual studio上预编译头文件 （不可缺少，否则在使用#include时会出错，其实里面什么都没有）以下是我的三个文件的实现代码
pch.h文件
//pch.h 头文件代码
#ifndef _pch_h_
#define _pch_h_
#endif
huffman.h文件
//huffman.h 头文件代码
#ifndef _HUFFMAN_H_
#define _HUFFMAN_H_
//Huffman树节点
struct HTNode
{
int nWeight;//权值
int nParent;//父节点
int nLchild;//左孩子
int nRchild;//右孩子
};
//Huffman树
typedef HTNode *HTree;//动态分配数组存储Huffman树
typedef char **HCode;//动态分配数组存储Huffman编码表
//生成Huffman树
int HuffmanTree(HTree &pHT, int *aWeight);
//选择Huffman树前nSize个元素中parent为0且weight最小的节点，返回其序号
int Select(HTree pHT, int nSize);
//测试函数，在控制台输入Huffman树每个节点信息
void TestHufTree(HTree &pHT);
//先序遍历Huffman树
void TestHufTreeN(int root,HTree &pHT);
//遍历Huffman树，生成Huffman编码
int HuffmanCoding(HCode &pHC, HTree &pHT);
//编写测试输出每个叶子节点的编码
void TestHufCode(int root, HTree pHT, HCode pHC);
#endif
compress.h文件
//compress.h 头文件代码
#ifndef _COMPRESS_H_
#define _COMPRESS_H_
#include "compress.h"
#include "huffman.h"
struct HEAD
{
char aType[4]; //文件类型
int nLength; //原文件长度
int aWeight[256]; //权值数值
};
//缓冲区
typedef char *BUFFER;
//压缩文件
int Compress(const char *pFilename);
//初始化文件头
int InitHead(const char *pFilename, HEAD &sHead);
//对文件进行编码压缩
int Encode(const char *pFilename, const HCode pHC, BUFFER &pBuffer, const int nSize);
//将“010101...”字符串编码成字节
char Str2byte(const char *pBinStr);
//写文件
int WriteFile(const char *pFilename, const HEAD sHead, const BUFFER pBuffer, const int nSize);
//test
void Testread(const char *pFilename);
#endif
接下来是三个源文件，compress.cpp，huffman.cpp，以及一个主函数main.cpp以下是我的三个文件的实现代码
compress.cpp代码
#include "compress.h"
#include "pch.h"
#include <stdlib.h>
#include <iostream>
using namespace std;
int Compress(const char *pFilename)
{
HEAD sHead;
if (InitHead(pFilename, sHead) == 0)
{
return 0;
}
cout << sHead.nLength << "字节" << endl;
//生成Huffman树
HTree pHT = NULL;
HuffmanTree(pHT, sHead.aWeight);
if (!pHT)
{
return 0;
}
//TestHufTree(pHT); //测试Huffman树的生成，各节点的权重，孩子和父节点
//TestHufTreeN(511,pHT); //测试Huffman树各个节点的权重
// 生成Huffman编码表
HCode pHC = NULL;
HuffmanCoding(pHC, pHT);
//TestHufCode(511, pHT, pHC); //查看Huffman编码
free(pHT);//释放Huffman空间
if (!pHC)
{
return 0;
}
//计算编码缓冲区的大小
int nSize = 0;
for (int i = 0; i < 256; i++)
{
nSize += sHead.aWeight[i] * strlen(pHC[i+1]);
}
nSize = (nSize % 8) ? nSize / 8 + 1 : nSize / 8;
//对原文件进行压缩编码
BUFFER pBuffer = NULL;
Encode(pFilename, pHC, pBuffer, nSize);
if (!pBuffer)
{
return 0;
}
//输出压缩文件
int len = WriteFile(pFilename, sHead, pBuffer, nSize);
free(pBuffer);
if (len < 0)
{
return 0;
}
cout << len << "字节" << endl;
cout << "压缩比率：" << (double)len / (double)sHead.nLength * 100 << "%" << endl;
return 1;
}
int InitHead(const char *pFilename, HEAD &sHead)
{
//初始化文件头
strcpy(sHead.aType, "HUF");//文件类型
sHead.nLength = 0;//原文件长度
for (int i = 0; i < 256; i++)//SIZE变成256
{
sHead.aWeight[i] = 0;//权值
}
//以二进制流形式打开文件
FILE *in = fopen(pFilename, "rb");
if (!in)
{
cerr << "初始化文件头失败！" << endl;
return 0;
}
//扫描文件，获取权重
int ch;
while ((ch = fgetc(in)) != EOF)
{
sHead.aWeight[ch]++;
sHead.nLength++;
}
//关闭文件,释放文件指针
fclose(in);
in = NULL;
return 1;
}
int Encode(const char *pFilename, const HCode pHC, BUFFER &pBuffer, const int nSize)
{
//以二进制流形式打开文件
FILE *in = fopen(pFilename, "rb");
if (!in)
{
cerr << "打开文件失败！" << endl;
return 0;
}
//开辟缓冲区
pBuffer = (char*)malloc(nSize * sizeof(char));
if (!pBuffer)
{
cerr << "开辟缓冲区失败 " << endl;
return 0;
}
char cd[256] = { 0 };//工作区 SIZE变成256
int pos = 0;//缓冲区指针
int ch;
//扫描文件，根据Huffman编码表对其进行压缩，压缩结果暂存到缓冲区中
while ((ch = fgetc(in)) != EOF)
{
strcpy(cd, pHC[ch+1]);//从 HC复制编码串到 cd
//压缩编码
while (strlen(cd) >= 8)
{
//截取字符串左边的8个字符，编码成字节
pBuffer[pos++] = Str2byte(cd);
//字符串整体左移8字节
for (int i = 0; i < 256 - 8; i++)//SIZE变成256
{
cd[i] = cd[i + 8];
}
}
}
if (strlen(cd) > 0)
{
pBuffer[pos++] = Str2byte(cd);
}
fclose(in);
return 1;
}
char Str2byte(const char *pBinStr)
{
char b = 0x00;
for (int i = 0; i < 8; i++)
{
b = b << 1; //左移一位
if (pBinStr[i] == '1')
{
b = b | 0x01;
}
}
return b;
}
int WriteFile(const char *pFilename, const HEAD sHead, const BUFFER pBuffer, const int nSize)
{
//生成文件名
char filename[256] = { 0 };
strcpy(filename, pFilename);
strcat(filename, ".huf");
//以二进制流形式打开文件
FILE *out = fopen(filename, "wb");
//....
//写文件头
fwrite(&sHead, sizeof(HEAD), 1, out);
//写压缩后的编码
fwrite(pBuffer, sizeof(char), nSize, out);
//关闭文件，释放文件指针
fclose(out);
out = NULL;
cout << "生成压缩文件：" << filename << endl;
int len = sizeof(HEAD) + strlen(pFilename) + 1 +nSize;
return len;
}
void Testread(const char *pFilename)
{
int ch;
int Weight[256] = { 0 };
//以二进制流形式打开文件
FILE *in = fopen(pFilename, "rb");
//扫描文件，获得权重
while ((ch = getc(in)) != EOF)
{
Weight[ch]++;
}
fclose(in);
cout<<"原文件每个字符的权值为："<<endl;
cout << "Byte" << " Weight" << endl;
for (int i = 0; i < 256; i++)
{
printf("0x%02X %d\n", i,Weight[i]);
}
}
huffman.cpp代码
#include "huffman.h"
#include "pch.h"
#include <stdlib.h>
#include <iostream>
using namespace std;
int HuffmanTree(HTree &pHT, int *aWeight)
{
//开辟空间
int m = 2 * 256 - 1;//SIZE变成256
pHT = (HTree)malloc((m + 1) * sizeof(HTNode));
if (!pHT)
{
cerr << "内存分配失败!" << endl;
return 0;
}
//初始化树
HTree p = pHT + 1;//0号单元未使用
for (int i = 0; i < m; i++)
{
p->nWeight = (i < 256) ? aWeight[i] : 0;//SIZE变成256
p->nParent = 0;
p->nLchild = 0;
p->nRchild = 0;
p++;
}
//创建Huffman树
for (int i = 256 + 1; i <= m; i++)//SIZE变成256
{
//第一个最小元素
int s1 = Select(pHT, i - 1);
pHT[s1].nParent = i;
//第二个最小元素
int s2 = Select(pHT, i - 1);
pHT[s2].nParent = i;
pHT[i].nWeight = pHT[s1].nWeight + pHT[s2].nWeight;
pHT[i].nLchild = s1;
pHT[i].nRchild = s2;
pHT[i].nParent = 0;
}
pHT[0].nLchild = 0;
pHT[0].nParent = 0;
pHT[0].nRchild = 0;
pHT[0].nWeight = 0;
return 1;
}
int Select(HTree pHT, int nSize)
{
int minValue = 0x7FFFFFFF; //最小值
int min = 0;//元素序号
//找到最小权值的元素序号
for (int i = 1; i <= nSize; i++)
{
if (pHT[i].nParent == 0 && pHT[i].nWeight < minValue)
{
minValue = pHT[i].nWeight;
min = i;
}
}
return min;
}
void TestHufTree(HTree &pHT)
{
cout << "Byte " << "Weignt " << "Parent " << "Lchild " << "Rchild" << endl;
for (int i = 1; i < 512; i++)
{
printf("pHT[%d]\t%d\t%d\t%d\t%d\n", i, pHT[i].nWeight, pHT[i].nParent, pHT[i].nLchild, pHT[i].nRchild);
}
}
void TestHufTreeN(int root, HTree &pHT)
{
cout <<pHT[root].nWeight << " ";
if (pHT[root].nLchild != 0)
{
TestHufTreeN(pHT[root].nLchild, pHT);
}
if (pHT[root].nRchild != 0)
{
TestHufTreeN(pHT[root].nRchild, pHT);
}
}
void TestHufCode(int root, HTree pHT, HCode pHC)
{
if (pHT[root].nLchild == 0 && pHT[root].nRchild == 0)
{
printf("0x%02X %s\n", root-1, pHC[root]);
}
if (pHT[root].nLchild)
{
TestHufCode(pHT[root].nLchild, pHT, pHC);
}
if (pHT[root].nRchild)
{
TestHufCode(pHT[root].nRchild, pHT, pHC);
}
}
int HuffmanCoding(HCode &pHC, HTree &pHT)
{
//无栈非递归遍历 Huffman树，求Huffman编码
char cd[256] = { '\0' };//记录访问路径
int cdlen = 0;//记录当前路径长度
pHC = (char**)malloc(300 * sizeof(int));
for (int i = 1; i < 512; i++)
{
pHT[i].nWeight = 0;//遍历 Huffman树时用作节点状态标志
}
int p = 511;//根节点
while (p != 0)
{
if (pHT[p].nWeight == 0)//向左
{
pHT[p].nWeight = 1;
if (pHT[p].nLchild != 0)
{
p = pHT[p].nLchild;
cd[cdlen++] = '0';
}
else if (pHT[p].nRchild == 0)//登记叶子节点的字符编码
{
pHC[p] = (char*)malloc((cdlen + 1) * sizeof(char));
cd[cdlen] = '\0';
strcpy(pHC[p], cd);//复制编码
}
}
else if (pHT[p].nWeight == 1)//向右
{
pHT[p].nWeight = 2;
if (pHT[p].nRchild != 0)//右孩子为叶子节点
{
p = pHT[p].nRchild;
cd[cdlen++] = '1';
}
}
else
{
//退回父节点。编码长度减 1
pHT[p].nWeight = 0;
p = pHT[p].nParent;
--cdlen;
} //权重为1时显示已经遍历了左孩子，权重为2时已经遍历了右孩子
}
return 1;//原文中写的是返回OK，这里用1来代表
}
main.cpp文件
#include "pch.h"
#include "compress.h"
#include <iostream>
using namespace std;
int main()
{
char filename[256];
cout << "==========Huffman文件压缩 ==========" << endl;
cout << "请输入文件名 ：";
cin >> filename;
Compress(filename);
getchar();
return 0;
}
运行结果如下：
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
