Huffman编码
Huffman编码是最流行的基于统计学的数据压缩方法，下面我们简单介绍它的实现步骤：
1. 将信源符号按照概率递减顺序排列；
2. 取两个概率最小的符号分别分配以“0”和“1”，然后把它们的概率相加，并作为一个新的符号的概率，与其它未分配符号按照（1）重新排列；
3. 重复（1）（2）过程，直至所有概率相加得1；
4. 寻找从每一个信源符号到概率为1处的路径，记录下路径上的“0”和“1”；
5. 写出每一个符号的“0”和“1”序列（从树根到信源符号节点）。
缺点：
从理论上讲，采用Huffman编码可以获得最佳编码效果，但是在实际中，由于计算机中存储和处理的最小数据单位是比特(bit)，因此在某种情况下，实际的压缩编码效果往往达不到理论的压缩比。例如：信源符号{X, Y}，其对应的概率为{2/3, 1/3}，则根据理论计算，符号X, Y的最佳码长分别是：X: log(2/3)2 = 0.588(bit)，Y: log(1/3)2 = 1.58(bit)
这表明，要获得最佳效果，符号{X, Y }的码字长度应分别为0.588bit和1.58bit，而计算机不可能有非整数位出现，只能按整数位进行，即采用哈夫曼编码对{X,Y}进行编码，得{X,Y}的码字分别为0和1，也就是两符号的信息编码长度都为1。可见，对于大概率符号X并未赋予较短的码字，实际编码效果没有达到理论编码效果。由上述分析可见，Huffman编码的主要缺点在于其编码方法是对每个符号进行编码，每个符号的码长只能是整数。为此提出算术编码，以解决计算机中必须以整数位进行编码的问题。
编码实现：
头文件
/ Huffman.h: interface for the Huffman class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_HUFFMAN_H__08A1863A_6641_4FE9_9596_5EEBE76B53F7__INCLUDED_)
#define AFX_HUFFMAN_H__08A1863A_6641_4FE9_9596_5EEBE76B53F7__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <string>
/***********************数据结构***********************/
//哈弗曼树节点
typedef struct
{
unsigned int weight;
unsigned int parent;
unsigned int lchild;
unsigned int rchild;
}HuffTreeNode,*HuffTree;
//字符-权值-编码映射
typedef struct
{
char c;
unsigned int weight;
char *code;
}CharMapNode,*CharMap;
/*************************类定义****************************/
class Huffman
{
private:
void select(int n, int &s1, int &s2);
HuffTree huffTree; //哈弗曼树
CharMap chars; //字符表
int n; //字符数
std::string text; //原文
std::string code; //编码
public:
void InputCharsWeight();
void CountCharsWeight();
void Decode();
void ReadTextFromFile(char *filename);
void ReadCodeFromFile(char *filename);
void SaveTextToFile(char *filename);
void SaveCodeToFile(char *filename);
void PrintCode();
void MakeCharMap();
void PrintText();
void PrintCharCode();
void PrintCharWeight();
void SetCharMap(CharMap m, int number);
void Encode();
Huffman();
virtual ~Huffman();
};
#endif // !defined(AFX_HUFFMAN_H__08A1863A_6641_4FE9_9596_5EEBE76B53F7__INCLUDED_)
Huffman类
// Huffman.cpp: implementation of the Huffman class.
//
//////////////////////////////////////////////////////////////////////
#include "Huffman.h"
#include <iostream>
#include <fstream>
using namespace std;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Huffman::Huffman()
{
huffTree = NULL;
chars = NULL;
n = 0;
}
Huffman::~Huffman()
{
}
//对Text串进行哈弗曼编码
void Huffman::Encode()
{
code = "";
for (string::size_type i = 0; i != text.size(); ++i)
{
for (int j = 1; j <= n; ++j)
if (chars[j].c == text[i])
code += chars[j].code; //code为数组名，可表示数组存放的地址
}
}
//设置字符表
void Huffman::SetCharMap(CharMap m, int number)
{
chars = m;
n = number;
}
//在huffTree[1..n]中选择parent为0且weight最小的两个节点，其序号为s1，s2
void Huffman::select(int n, int &s1, int &s2)
{
s1 = s2 = 0;
for (int i = 1; i <= n; ++i)
{
if (huffTree[i].parent != 0)
continue;
if (s1 == 0)
s1 = i;
else if (s2 == 0)
{
//此处采用的策略，使得整个过程中s1的权值小于s2的权值
if (huffTree[i].weight < huffTree[s1].weight)
{
s2 = s1;
s1 = i;
}
else
s2 = i;
}
else
{
if (huffTree[i].weight < huffTree[s1].weight)
{
s2 = s1;
s1 = i;
}
else if (huffTree[i].weight < huffTree[s2].weight)
s2 = i;
}
}
}
void Huffman::PrintCharWeight()
{
for (int i = 1; i <= n; ++i)
{
/* switch (chars[i].c)
{
case '\t':
cout << "\\t";
break;
case '\n':
cout << "\\n";
break;
default:*/
cout << chars[i].c;
// break;
//}
cout << "——" << chars[i].weight << endl;
}
}
void Huffman::PrintCharCode()
{
for (int i = 1; i <= n; ++i)
{
/*switch (chars[i].c)
{
case '\t':
cout << "\\t";
break;
case '\n':
cout << "\\n";
break;
default:*/
cout << chars[i].c;
// break;
//}
cout << "——" << chars[i].code << endl;
}
}
//输出文本串
void Huffman::PrintText()
{
cout << text << endl;
}
//输出0-1编码
void Huffman::PrintCode()
{
cout << code << endl;
}
//根据各字符的权值建立字符-编码表
void Huffman::MakeCharMap()
{
if (n <= 1)
return;
int m = 2 * n - 1; //哈弗曼树所需节点数
huffTree = new HuffTreeNode[m+1]; //0号单元未使用
//初始化
int i;
for (i = 1; i <= n; ++i) //从1开始
{
huffTree[i].weight = chars[i].weight;
huffTree[i].parent = 0;
huffTree[i].lchild = 0;
huffTree[i].rchild = 0;
}
for (i = n + 1; i <= m; ++i)
{
huffTree[i].weight = 0;
huffTree[i].parent = 0;
huffTree[i].lchild = 0;
huffTree[i].rchild = 0;
}
//建哈弗曼树
for (i = n + 1; i <= m; ++i)
{
int s1,s2;
select(i - 1, s1, s2);
huffTree[s1].parent = huffTree[s2].parent = i;
huffTree[i].lchild = s1;
huffTree[i].rchild = s2;
huffTree[i].weight = huffTree[s1].weight + huffTree[s2].weight;
}
//从叶子到根节点逆向求每个字符的哈弗曼编码
char *cd = new char[n]; //分配求编码的工作空间（每个字符编码结果最长n-1再加上'\0'）
cd[n-1] = '\0'; //编码结束符
for(i = 1; i <= n; ++i) //逐个字符求哈弗曼编码
{
int start = n - 1;
int c,f;
//从叶子到根逆向求编码
for (c = i, f = huffTree[i].parent; f != 0; c = f, f = huffTree[f].parent)
{
if (huffTree[f].lchild == c) //左孩子编码为0
cd[--start] = '0';
else //右孩子编码为1
cd[--start] = '1';
}
chars[i].code = new char[n - start]; //为第i个字符编码分配空间
strcpy(chars[i].code,&cd[start]);
}
delete cd;
}
//从文件读入原文
void Huffman::ReadTextFromFile(char *filename)
{
ifstream infile(filename);
if(!infile)
{
cerr << "无法打开文件！" <<endl;
return;
}
char c;
while(infile.get(c))
{
text += c;
}
}
//将编码存入文件
void Huffman::SaveCodeToFile(char *filename)
{
ofstream outfile(filename);
if (!outfile)
{
cerr << "保存文件出错！" << endl;
return;
}
outfile << code;
}
//从文件读入编码
void Huffman::ReadCodeFromFile(char *filename)
{
ifstream infile(filename);
if (!infile)
{
cerr << "无法打开文件！" <<endl;
return;
}
infile >> code;
}
//将0-1编码串解码
void Huffman::Decode()
{
text = "";
string::size_type i,count;
for (i = 0; i < code.size(); i += count)
{
//每个字符的编码结果最长n-1，从1至n-1依次尝试
for (count = 1; count < n; ++count)
{
for (int j = 1; j <= n; ++j)
if (code.substr(i, count) == chars[j].code)//code.substr(a,b)表示对字符串code截取从第a个到第b个，依次与chars[].code比较
{
text += chars[j].c; //text表示原文存放的数组名，作指针使用
goto next;
}
}
next:
;
}
}
//统计原文中各字符的权值
void Huffman::CountCharsWeight()
{
if (text.empty())
return;
if (chars != NULL)
delete chars;
int i = 0;
n = 0;
chars = new CharMapNode[2];
chars[1].c = text[i];
chars[1].weight = 1;
++n;
for (i = 1; i != text.size(); ++i)
{
int j;
for (j = 1; j <= n; ++j) //遍历当前字符表，如果已存在该字符，权值+1
{
if (text[i] == chars[j].c)
{
++chars[j].weight;
break;
}
}
if (j > n) //该字符不存在，添加该字符
{
++n;
CharMap newchars = new CharMapNode[n + 1];
memcpy(newchars, chars, n * sizeof(CharMapNode));
delete chars;
chars = newchars;
chars[n].c = text[i];
chars[n].weight = 1;
}
}
}
//输入字符和对应权值
void Huffman::InputCharsWeight()
{
cout << "请输入字符集大小n（n>1）:" << endl;
cin >> n;
if (chars != NULL)
delete chars;
chars = new CharMapNode[n+1]; //0号单元未使用
cout << "请输入字符和权值：" << endl;
for (int i = 1; i <= n; ++i)
{
cin.ignore(); //清除输入缓冲区
cin.get(chars[i].c); //输入单个字符，可以是空白符
cin >> chars[i].weight;
}
}
void Huffman::SaveTextToFile(char *filename)
{
ofstream outfile(filename);
if (!outfile)
{
cerr << "保存文件出错！" << endl;
return;
}
outfile << text;
}
主函数
#include <iostream>
#include "Huffman.h"
using namespace std;
int main()
{
Huffman huffman;
huffman.ReadTextFromFile("text.txt");
/****************第一步输入字符和对应权值******************/
cout << "请选择： 1.程序自动统计字符和权值（推荐） 2.用户输入" << endl;
int r;
do
{
cin >> r;
}
while((r != 1) && (r != 2));
if (r == 1)
huffman.CountCharsWeight();
else
huffman.InputCharsWeight();
cout << "字符及对应权值：" << endl;
huffman.PrintCharWeight(); //计算每个字符对应的权值
system("pause");
cout << endl;
/****************第二步建哈弗曼树，输出字符与编码的对应关系******************/
huffman.MakeCharMap(); //实现哈弗曼编码，对应存入chars[i].c-chars[i].code
cout << "字符及对应的编码：" << endl;
huffman.PrintCharCode(); //打印每个字符及其对应的编码，即chars[i].c-chars[i].code
system("pause");
cout << endl;
/****************第三步对字符进行编码，将结果输出并存入文件******************/
cout << "对原文进行编码：" << endl;
cout << "原文：" << endl;
huffman.PrintText(); //输出文本串
huffman.Encode(); //对文本串进行编码
cout << "编码：" << endl;
huffman.PrintCode();
huffman.SaveCodeToFile("code.txt");
system("pause");
cout << endl;
/****************第四步从文件读入0、1代码串解码后输出并存入文件******************/
cout << "对编码进行解码：" << endl;
huffman.ReadCodeFromFile("code.txt");
cout << "编码：" << endl;
huffman.PrintCode();
huffman.Decode();
cout << "原文：" << endl;
huffman.PrintText();
huffman.SaveTextToFile("resulttext.txt");
cout << "\n Over ^_^" << endl;
system("pause");
return 0;
}
输出界面