霍夫曼编辑压缩信源码PPT

‘壹’ 已知6个符号的信源A={a1，a2，……a6}，若其概率分布为P={0.30, 0.25, 0.25, 0.10}1、写出Huffman编码（要

1、写出Huffman编码

a6和a5组成n1节点，权重0.14

a4和n1组成n2节点，权重0.26

a3和a2组成n3节点，权重0.42

n2和a1组成n4节点，权重0.58

n3和n4组成n5节点，权重1，即为根节点

Huffman编码：

a1: 11

a2: 01

a3: 00

a4: 100

a5: 1011

a6: 1010

2、Huffman编码的平均编码长度

2 * (0.32 + 0.25 + 0.17) + 3 * 0.12 + 4 * (0.09 + 0.05)

= 1.48 + 0.36 + 0.56

= 2.4

3、压缩比

如果不用Huffman编码，则6个符号需要3个二进制符号，编码长度是3，所以压缩比是3 / 2.4 =1.25

扩展内容

哈夫曼编码(Huffman Coding)原理

设某信源产生有五种符号u1、u2、u3、u4和u5，对应概率P1=0.4，P2=0.1，P3=P4=0.2，P5=0.1。首先，将符号按照概率由大到小排队，如图所示。

编码时，从最小概率的两个符号开始，可选其中一个支路为0，另一支路为1。这里，我们选上支路为0，下支路为1。再将已编码的两支路的概率合并，并重新排队。多次重复使用上述方法直至合并概率归一时为止。

赫夫曼码的码字（各符号的代码）是异前置码字，即任一码字不会是另一码字的前面部分，这使各码字可以连在一起传送，中间不需另加隔离符号，只要传送时不出错，收端仍可分离各个码字，不致混淆。

长游程的主码和基码均用赫夫曼规则进行编码，这称为修正赫夫曼码，其结果有表可查。该方法已广泛应用于文件传真机中。

‘贰’ 霍夫曼编码

霍夫曼(Huffman)在1952年提出
是一种从下到上的编码方法，即从叶子逐步往上生成编码树
编码算法实际上是一个构造霍夫曼树的过程（根据资料出现频率的多寡来建造的树，霍夫曼树的树叶节点用以储存资料元素 ( Data Element ) ，若该元素出现的频率越高，则由该元素至树根所经过的节点数越少）
(1) 对资料中出现过的每一元素各自产生一外部节点，并赋予外部节点该元素之出现频率。
(2) 令 L 是所有外部节点所成之集合。
(3) 产生一个新节点 N 。令 N 为 L1 和 L2 的父节点，L1 和 L2 是 L 中出现频率最低的两个节点。令 N 节点的出现频率等于 L1 和 L2 的出现频率总和。由 L 中删除 L1 和 L2 ，并将 N 加入 L 中。
(4) 重复步骤 (3) 的动作，直到 | L | = 1 。
(5) 标示树中各节点的左子树链结为 0 ，右子树链结为 1 。（不一定，只要一枝为0一枝为1）
是码长可变的编码
霍夫曼算法和香农范诺算法的编码都不需要额外的同步码（解释）
霍夫曼树是最小二叉树，编码效率比香农范诺高
霍夫曼编码对错误敏感，错一位，可能导致后面的解码都是错误的，而且计算机也无法纠错，我们称为错误传播
霍夫曼编码是变长编码，整个编码结果是一个整体，无法随意解压缩其中的某一个部分

‘叁’ Huffman(霍夫曼)编码是如何运算的

霍夫曼（Huffman）编码原理
霍夫曼（Huffman）编码是1952年为文本文件而建立，是一种统计编码。属于无损压缩编码。
霍夫曼编码的码长是变化的，对于出现频率高的信息，编码的长度较短；而对于出现频率低的信息，编码长度较长。这样，处理全部信息的总码长一定小于实际信息的符号长度。

步骤进行：
l）将信号源的符号按照出现概率递减的顺序排列。
2）将两个最小出现概率进行合并相加，得到的结果作为新符号的出现概率。
3）重复进行步骤1和2直到概率相加的结果等于1为止。
4）在合并运算时，概率大的符号用编码0表示，概率小的符号用编码1表示。
5）记录下概率为1处到当前信号源符号之间的0，l序列，从而得到每个符号的编码。

例：
设信号源为 s＝｛s1, s2, s3, s4, s5｝
对应的概率为p＝｛0.25，0.22，0.20, 0.18，0.15｝。

根据字符出现的概率来构造平均长度最短的异字头码字。
霍未曼编码通常采用两次扫描的办法，第一次扫描得到统计结果，第二次扫描进行编码。

霍夫曼编码具有一些明显的特点：
1) 编出来的码都是异字头码，保证了码的唯一可译性。
2) 由于编码长度可变。因此译码时间较长，使得霍夫曼编码的压缩与还原相当费时。
3) 编码长度不统一，硬件实现有难度。
4) 对不同信号源的编码效率不同，当信号源的符号概率为2的负幂次方时，达到100％的编码效率；若信号源符号的概率相等，则编码效率最低。
5) 由于"0"与"1"的指定是任意的，故由上述过程编出的最佳码不是唯一的，但其平均码长是一样的，故不影响编码效率与数据压缩性能。

‘肆’ 利用huffman树实现文件的压缩与解压

这是本人写的动态哈夫曼压缩算法实现，压缩与解压缩时，
根据文件内容自动生成哈夫曼树，并动态调整节点的权重
和树的形状。900MHZ的PIII赛扬每秒钟可以压缩的好几MB
的数据，只是压缩率不高，文本文件的压缩后容量一般可
以减少25%，比RAR差远了。

源文件共三个，你在VC6.0中新建一个空的命令行项目，
将它们加进去，编译完就可以用了。

===========hfm.cpp===================

#include <stdio.h>
#include <string.h>
#include <io.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "Huffman.h"

int wh;
int rh;

bool Write(unsigned char *s,int len){
_write(wh,s,len);
return true;
}

bool OpenFile(char* source,char* target){
int w_flag=_O_WRONLY | _O_CREAT | _O_EXCL | _O_BINARY;
int r_flag=_O_RDONLY | _O_BINARY;

rh=_open(source,r_flag,_S_IREAD | _S_IWRITE);
wh=_open(target,w_flag,_S_IREAD | _S_IWRITE);

if(rh==-1 || wh==-1){
if(rh!=-1){
_close(rh);
printf("\n打开文件：'%s'失败!",target);
}
if(wh!=-1){
_close(wh);
printf("\n打开文件：'%s'失败!",source);
}

return false;
}else{
return true;
}
}

void PrintUsage(){
printf("\n以动态哈夫曼算法压缩或解压缩文件。\n\n");
printf("\thfm -?\t\t\t\t显示帮助信息\n");
printf("\thfm -e -i source -o target\t压缩文件\n");
printf("\thfm -d -i source -o target\t解压缩文件\n\n");
}

void main(int argc,char *args[]){
int mode,i,j,K=0;
char src[4096];
char target[4096];
unsigned char buffer[BUFFER_SIZE];
Huffman *h;

mode=0;
for(i=1;i<argc;i++){
if(args[i][0]=='-' || args[i][0]=='/'){
switch(args[i][1]){
case '?':
mode=0;//帮助
break;
case 'e':
case 'E':
mode=1;//压缩
break;
case 'd':
case 'D':
mode=2;//解压缩
break;
case 'o':
case 'O':
if(i+1>=argc){
mode=0;
}else{//输出文件
j=0;
while(args[i+1][j]!='\0' && j<4096){
target[j++]=args[i+1][j];
}
if(j==4096){
mode=0;
}else{
target[j]='\0';
K |= 1;
}
}
break;
case 'i':
case 'I':
if(i+1>=argc){
mode=0;
}else{//输入文件
j=0;
while(args[i+1][j]!='\0' && j<4096){
src[j++]=args[i+1][j];
}
if(j==4096){
mode=0;
}else{
src[j]='\0';
K |=2;
}
}
break;
}
}
}

if(K!=3)mode=0;

switch(mode){
case 0:
PrintUsage();
return;
case 1://压缩
if(!OpenFile(src,target))return;
h=new Huffman(&Write,true);
i=BUFFER_SIZE;
while(i==BUFFER_SIZE){
i=_read(rh,buffer,BUFFER_SIZE);
h->Encode(buffer,i);
}
delete h;
_close(rh);
_close(wh);
printf("压缩完毕!");
break;
case 2://解压缩
if(!OpenFile(src,target))return;
h=new Huffman(&Write,false);
i=BUFFER_SIZE;
while(i==BUFFER_SIZE){
i=_read(rh,buffer,BUFFER_SIZE);
h->Decode(buffer,i);
}
delete h;
_close(rh);
_close(wh);
printf("解压缩完毕!");
break;
}

}

=======end of hfm.cpp=======================

=======Huffman.cpp=============================
// Huffman.cpp: implementation of the Huffman class.
//
//////////////////////////////////////////////////////////////////////

#include "Huffman.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Huffman::Huffman(Output *output,bool mode)
{
Hbtree *tmp;
int i;

this->mode=mode;

//设置输出函数，当缓冲区满时，将调用该函数输出
this->output=output;

//初始化列表
for(i=0;i<LIST_LENGTH;i++)this->list[i]=NULL;

//初始化哈夫曼树
this->root=this->NewNode(NOT_CHAR,LEFT,NULL);
this->current=this->root;
tmp=this->NewNode(CODE_ESCAPE,RIGHT,root);
tmp->count=1;
tmp=this->NewNode(CODE_FINISH,LEFT,root);
tmp->count=0;
root->count=root->child[LEFT]->count+root->child[RIGHT]->count;

//设置缓冲区指针
this->char_top=BOTTOM_BIT;
this->bit_top=TOP_BIT;
this->buffer[0]=0;

//重构哈夫曼树的最大计数值
this->max_count=MAX_COUNT;
this->shrink_factor=SHRINK_FACTOR;
this->finished=false;
}

Huffman::~Huffman()
{
if(this->mode==true){//如果是编码
//输出结束码
this->OutputEncode(CODE_FINISH);
this->char_top++;
}

//强制清空缓冲区
this->Flush();

//释放空间
this->ReleaseNode(this->root);
}

Hbtree * Huffman::NewNode(int value, int index, Hbtree *parent)
{
Hbtree *tmp=new Hbtree;
tmp->parent=parent;
tmp->child[0]=NULL;
tmp->child[1]=NULL;
tmp->count=(1 << SHRINK_FACTOR);
tmp->index=(index==0) ? 0 : 1;
tmp->value=value;

if(value!=NOT_CHAR)this->list[tmp->value]=tmp;
if(parent!=NULL)parent->child[tmp->index]=tmp;
return tmp;
}

void Huffman::ReleaseNode(Hbtree *node)
{
if(node!=NULL){
this->ReleaseNode(node->child[LEFT]);
this->ReleaseNode(node->child[RIGHT]);
delete node;
}
}

//输出一位编码
int Huffman::OutputBit(int bit)
{
unsigned char candidates[]={1,2,4,8,16,32,64,128};

if(bit!=0)
this->buffer[this->char_top] |= candidates[this->bit_top];
this->bit_top--;
if(this->bit_top < BOTTOM_BIT){
this->bit_top=TOP_BIT;
this->char_top++;

if(this->char_top >= BUFFER_SIZE){//输出缓冲区
this->output(this->buffer,BUFFER_SIZE);
this->char_top=0;
}

this->buffer[this->char_top]=0;
}
return 0;
}

//输出缓冲区
int Huffman::Flush()
{
this->output(this->buffer,this->char_top);
this->char_top=0;
return 0;
}

int Huffman::Encode(unsigned char c)
{
int value=c,
candidates[]={128,64,32,16,8,4,2,1},
i;

if(this->list[value]==NULL){//字符不存在于哈夫曼树中
//输出转义码
this->OutputEncode(CODE_ESCAPE);
//输出字符
for(i=0;i<8;i++)this->OutputBit(value & candidates[i]);

this->InsertNewNode(value);

}else{
//输出字符编码
this->OutputEncode(value);

//重新调整哈夫曼树
this->BalanceNode(this->list[value]->parent);
}

//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();

return 0;
}

void Huffman::BalanceNode(Hbtree *node)
{
Hbtree *parent,*child,*brother;
int i,j;

parent=node->parent;
if(parent==NULL)return;//根节点无需调整

if(node->value==NOT_CHAR){//非叶子节点
child=node->child[LEFT]->count > node->child[RIGHT]->count ?
node->child[LEFT] : node->child[RIGHT];

if(child->count > parent->count - node->count){
//失衡

i=!(node->index);
j=child->index;
node->count=parent->count - child->count;
brother=parent->child[i];

node->child[j]=brother;
brother->index=j;
brother->parent=node;

parent->child[i]=child;
child->index=i;
child->parent=parent;
}
}
this->BalanceNode(parent);
}

//输出一个字符的编码
int Huffman::OutputEncode(int value)
{
int stack[CODE_FINISH+2],top=0;
Hbtree *tmp=this->list[value];

//输出编码
if(value<=MAX_VALUE){//字符
while(tmp!=NULL){
stack[top++]=tmp->index;
tmp->count++;
tmp=tmp->parent;
}
}else{//控制码
while(tmp!=NULL){
stack[top++]=tmp->index;
tmp=tmp->parent;
}
}
top--;
while(top>0){
this->OutputBit(stack[--top]);
}

return 0;
}

void Huffman::PrintNode(Hbtree *node,int level)
{
int i;
if(node){
for(i=0;i<level*3;i++)printf(" ");
printf("%p P:%p L:%p R:%p C:%d",node,node->parent,node->child[0],node->child[1],node->count);
if(node->value!=NOT_CHAR)printf(" V:%d",node->value);
printf("\n");

this->PrintNode(node->child[LEFT],level+1);
this->PrintNode(node->child[RIGHT],level+1);
}
}

int Huffman::Encode(unsigned char *s, int len)
{
int i;
for(i=0;i<len;i++)this->Encode(s[i]);
return 0;
}

void Huffman::PrintTree()
{
this->PrintNode(this->root,0);
}

int Huffman::RecountNode(Hbtree *node)
{
if(node->value!=NOT_CHAR)return node->count;
node->count=
this->RecountNode(node->child[LEFT]) +
this->RecountNode(node->child[RIGHT]);
return node->count;
}

void Huffman::RearrangeTree()
{
int i,j,k;
Hbtree *tmp,*tmp2;

//所有非控制码的计数值右移shrink_factor位，并删除计数值为零的节点
for(k=0;k<=MAX_VALUE;k++){
if(this->list[k]!=NULL){
tmp=this->list[k];
tmp->count >>= this->shrink_factor;
if(tmp->count ==0){
this->list[k]=NULL;
tmp2=tmp->parent;
i=tmp2->index;
j=!(tmp->index);
if(tmp2->parent!=NULL){
tmp2->parent->child[i]=tmp2->child[j];
tmp2->child[j]->parent=tmp2->parent;
tmp2->child[j]->index=i;
}else{
this->root=tmp2->child[j];
this->current=this->root;
this->root->parent=NULL;
}
delete tmp;
delete tmp2;
}
}
}

//重新计数
this->RecountNode(this->root);

//重新调整平衡
for(i=0;i<=MAX_VALUE;i++){
if(this->list[i]!=NULL)
this->BalanceNode(this->list[i]->parent);
}
}

void Huffman::InsertNewNode(int value)
{
int i;
Hbtree *tmp,*tmp2;

//将字符加入哈夫曼树
tmp2=this->list[CODE_FINISH];
tmp=this->NewNode(NOT_CHAR, tmp2->index, tmp2->parent);
tmp->child[LEFT]=tmp2;
tmp2->index=LEFT;
tmp2->parent=tmp;

tmp2=this->NewNode(value,RIGHT,tmp);
tmp->count=tmp->child[LEFT]->count+tmp->child[RIGHT]->count;
i=tmp2->count;
while((tmp=tmp->parent)!=NULL)tmp->count+=i;
//从底向上调整哈夫曼树
this->BalanceNode(tmp2->parent);
}

int Huffman::Decode(unsigned char c)
{
this->Decode(c,7);
return 0;
}

int Huffman::Decode(unsigned char *s,int len)
{
int i;
for(i=0;i<len;i++)this->Decode(s[i]);
return 0;
}

int Huffman::Decode(unsigned char c, int start)
{
int value=c,
candidates[]={1,2,4,8,16,32,64,128},
i,j;
Hbtree *tmp;

if(this->finished)return 0;

i=start;
if(this->current==NULL){//转义状态下
while(this->remain >= 0 && i>=0){
if((candidates[i] & value) !=0){
this->literal |= candidates[this->remain];
}
this->remain--;
i--;
}

if(this->remain < 0){//字符输出完毕

//输出字符
this->OutputChar(this->literal);
//将字符插入哈夫曼树
this->InsertNewNode(literal);
//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();

//设置环境
this->current=this->root;
}
}else{
j=((value & candidates[i])!=0)?1:0;
tmp=this->current->child[j];
i--;
while(tmp->value==NOT_CHAR && i>=0){
j=((value & candidates[i])!=0)?1:0;
tmp=tmp->child[j];
i--;
}

if(tmp->value==NOT_CHAR){//中间节点
this->current=tmp;
}else{
if(tmp->value<=MAX_VALUE){//编码内容
j=tmp->value;
this->OutputChar((unsigned char)j);

//修改计数器
tmp=this->list[j];
while(tmp!=NULL){
tmp->count++;
tmp=tmp->parent;
}
//调整平衡度
this->BalanceNode(this->list[j]->parent);

//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();

//设置环境
this->current=this->root;
}else{
if(tmp->value==CODE_ESCAPE){//转义码
this->current=NULL;
this->remain=7;
this->literal=0;
}else{//结束码
this->finished=true;
return 0;
}
}
}

}

if(i>=0)this->Decode(c,i);
return 0;
}

int Huffman::OutputChar(unsigned char c)
{
this->buffer[this->char_top++]=c;
if(this->char_top>=BUFFER_SIZE){//输出缓冲区
this->output(this->buffer,BUFFER_SIZE);
this->char_top=0;
}
return 0;
}

========end of Huffman.cpp==================

========Huffman.h============================
// Huffman.h: interface for the Huffman class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(NULL)
#include <stdio.h>
#endif

#if !defined(AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_)
#define AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define MAX_COUNT 65536 //最大计数值，大于此值时
#define MAX_VALUE 255 //编码的最大值
#define CODE_ESCAPE MAX_VALUE+1 //转义码
#define CODE_FINISH MAX_VALUE+2 //结束码
#define LIST_LENGTH MAX_VALUE+3 //编码列表长度
#define SHRINK_FACTOR 2 //减小的比例，通过右移位实现
#define LEFT 0 //左孩子索引
#define RIGHT 1 //右孩子索引
#define NOT_CHAR -1 //非字符

#define TOP_BIT 7 //字符最高位
#define BOTTOM_BIT 0 //字符最低位
#define BUFFER_SIZE 81920 //缓冲区大小

//输出函数
typedef bool (Output)(unsigned char *s,int len);

//哈夫曼树的节点定义
typedef struct Hnode{
int count;//计数器
int index;//父节点的孩子索引（0--左孩子，1--右孩子）
Hnode* child[2];
Hnode* parent;
int value;
}Hbtree;

class Huffman
{
private:
//输出一个解码的字符
int OutputChar(unsigned char c);
//从指定位置开始解码
int Decode(unsigned char c,int start);
//插入一个新节点
void InsertNewNode(int value);
//重新调整哈夫曼树构型
void RearrangeTree();
//对各节点重新计数
int RecountNode(Hbtree *node);
//打印哈夫曼树节点
void PrintNode(Hbtree *node,int level);
//输出一个值的编码
int OutputEncode(int value);
//调节哈夫曼树节点使之平衡
void BalanceNode(Hbtree *node);
//输出一位编码
int OutputBit(int bit);
//释放哈夫曼树节点
void ReleaseNode(Hbtree *node);
//新建一个节点
Hbtree *NewNode(int value,int index, Hbtree *parent);
//输出函数地址
Output *output;
//哈夫曼树根地址
Hbtree *root;
//哈夫曼编码单元列表
Hbtree *list[LIST_LENGTH];
//输出缓冲区
unsigned char buffer[BUFFER_SIZE];
//缓冲区顶
int char_top,bit_top;
//收缩哈夫曼树参数
int max_count,shrink_factor;
//工作模式，true--编码，false--解码
bool mode;
//解码的当前节点
Hbtree *current;
int remain;//当前字符剩余的位数
unsigned char literal;//按位输出的字符
bool finished;

public:

//解码指定长度的字符串
int Decode(unsigned char *s,int len);
//解码一个字符
int Decode(unsigned char c);
//打印哈夫曼树
void PrintTree();
//编码指定长度的字符串
int Encode(unsigned char *s,int len);
//编码一个字符
int Encode(unsigned char c);
//清空缓冲区
int Flush();

//output指输出函数，mode指工作模式，true--编码，false--解码
Huffman(Output *output,bool mode);

//析构函数
virtual ~Huffman();
};

#endif // !defined(AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_)

================end of Huffman.h==================

祝你好运！

‘伍’ 利用huffman编码对文件进行压缩，不同文件类型压缩率有差别的原因

怎么没人回答呢 我来回答吧 我想从压缩文件的原理能得到你这个问题的答案（有点长，请耐心看，绝对长知识）： 压缩文件的运行原理 如果您从互联网上下载了许多程序和文件，可能会遇到很多ZIP文件。这种压缩机制是一种很方便的发明，尤其是对网络用户，因为它可以减小文件中的比特和字节总数，使文件能够通过较慢的互联网连接实现更快传输，此外还可以减少文件的磁盘占用空间。在下载了文件后，计算机可使用WinZip或Stuffit这样的程序来展开文件，将其复原到原始大小。如果一切正常，展开的文件与压缩前的原始文件将完全相同。
乍一听好像很神秘：您是怎样减少比特和字节的数量并将它们原封不动地还原回去的呢？等一切水落石出之后，您会发现这个过程背后的基本理念其实非常简单明了。在本文中，我们将讨论这种通过简单压缩来明显减小文件的方法。
大多数计算机文件类型都包含相当多的冗余内容——它们会反复列出一些相同的信息。文件压缩程序就是要消除这种冗余现象。与反复列出某一块信息不同，文件压缩程序只列出该信息一次，然后当它在原始程序中出现时再重新引用它。
以我们熟悉的信息类型——单词——为例子。
肯尼迪（John F. Kennedy）在1961年的就职演说中曾说过下面这段着名的话：
Ask not what your country can do for you——ask what you can do for your country.（不要问国家能为你做些什么，而应该问自己能为国家做些什么。）
这段话有17个单词，包含61个字母、16个空格、1个破折号和1个句点。如果每个字母、空格或标点都占用1个内存单元，那么文件的总大小为79个单元。为了减小文件的大小，我们需要找出冗余的部分。
我们立刻发现：
如果忽略大小写字母间的区别，这个句子几乎有一半是冗余的。九个单词（ask、not、what、your、country、can、do、for、you）几乎提供了组成整句话所需的所有东西。为了构造出另一半句子，我们只需要拿出前半段句子中的单词，然后加上空格和标点就行了。
大多数压缩程序使用基于自适应字典的LZ算法来缩小文件。“LZ”指的是此算法的发明者Lempel和Ziv，“字典”指的是对数据块进行归类的方法。
排列字典的机制有很多种，它也可以像编号列表那样简单。在我们检查肯尼迪这句着名讲话时，可以挑出重复的单词，并将它们放到编号索引中。然后，我们直接写入编号而不是写入整个单词。
因此，如果我们的字典是：
ask
what
your
country
can
do
for
you
我们的句子现在就应该是这样的：
1 not 2 3 4 5 6 7 8-- 1 2 8 5 6 7 3 4
如果您了解这种机制，那么只需使用该字典和编号模式即可轻松重新构造出原始句子。这就是在展开某个下载文件时，计算机中的解压缩程序所做的工作。你可能还遇到过能够自行解压缩的压缩文件。若要创建这种文件，编程人员需要在被压缩的文件中设置一个简单的解压缩程序。在下载完毕后，它可以自动重新构造出原始文件。
但是使用这种机制究竟能够节省多少空间呢？“1 not 2 3 4 5 6 7 8——1 2 8 5 6 7 3 4”当然短于“Ask not what your country can do for you-- ask what you can do for your country.”，但应注意的是，我们需要随文件一起保存这个字典。
在实际压缩方案中，计算出各种文件需求是一个相当复杂的过程。让我们回过头考虑一下上面的例子。每个字符和空格都占用1个内存单元，整个原句要占用79个单元。压缩后的句子（包括空格）占用了37个单元，而字典（单词和编号）也占用了37个单元。也就是说，文件的大小为74个单元，因此我们并没有把文件大小减少很多。
但这只是一个句子的情况！可以想象的是，如果用该压缩程序处理完肯尼迪讲话的其余部分，我们会发现这些单词以及其他单词重复了更多次。而且，正如下一节所言，为了得到尽可能高的组织效率，可以对字典进行重写。
在上一个的例子中，我们挑出了所有重复的单词并将它们放在一个字典中。对于我们来说，这是最显而易见的字典编写方法。但是压缩程序却不这样认为：它对单词没有概念——它只会寻找各个模式。为了尽可能减小文件的大小，它会仔细挑选出最优模式。
如果从这个角度处理该句子，我们最终会得到一个完全不同的字典。
如果压缩程序扫描肯尼迪的这句话，它遇到的第一个冗余部分只有几个字母长。在ask not what your中，出现了一个重复的模式，即字母t后面跟一个空格——在not和what中。如果压缩程序将此模式写入字典，则每次出现“t”后面跟一个空格的情况时，它会写入一个“1”。但是在这个短句中，此模式的出现次数不够多，不足以将其保留为字典中的一个条目，因此程序最终会覆盖它。
程序接下来注意到的内容是ou，在your和country中都出现了它。如果这是一篇较长的文档，将此模式写入字典会节省大量空间——在英语中ou是一个十分常见的字母组合。但是在压缩程序看完整个句子后，它立即发现了一个更好的字典条目选择：不仅ou发生了重复，而且your和country整个单词都发生了重复，并且它们实际上是作为一个短语your country一起发生重复的。在本例中，程序会用your country条目覆盖掉字典中的ou条目。
短语can do for也发生了重复，一次后面跟着your，另一次跟着you，因此我们又发现can do for you也是一种重复模式。这样，我们可以用一个数字来代替15个字符（包含空格），而your country只允许我们用一个数字代替13个字符（包含空格），所以程序会用r country条目覆盖your country条目，然后再写入一个单独的can do for you条目。程序通过这种方式继续工作，挑出所有重复的信息，然后计算应该将哪一种模式写入字典。基于自适应字典的LZ算法中的“自适应”部分指的就是这种重写字典的能力。程序执行此工作的过程实际上非常复杂。
无论使用什么方法，这种深入搜索机制都能比仅仅挑出单词这种方法更有效率地对文件进行压缩。如果使用我们上面提取出的模式，然后用“__”代替空格，最终将得到下面这个更大的字典：
ask__
what__­
you
r__country
__can__do__for__you
而句子则较短：
“1not__2345__--__12354”
句子现在占用18个内存单元，字典占用41个单元。所以，我们将文件总大小从79个单元压缩到了59个单元！这仅仅是压缩句子的一种方法，而且不一定是最高效的方法。（看看您能找到更好的方法吗！）
那么这种机制到底有多好呢？文件压缩率取决于多种因素，包括文件类型、文件大小和压缩方案。
在世界上的大多数语言中，某些字母和单词经常以相同的模式一起出现。正是由于这种高冗余性，而导致文本文件的压缩率会很高。通常大小合适的文本文件的压缩率可以达到50%或更高。大多数编程语言的冗余度也很高，因为它们的命令相对较少，并且命令经常采用一种设定的模式。对于包含大量不重复信息的文件（例如图像或MP3文件），则不能使用这种机制来获得很高的压缩率，因为它们不包含重复多次的模式。
如果文件有大量重复模式，那么压缩率通常会随着文件大小的增加而增加。从我们的例子中就可以看出这一点——如果我们摘录的肯尼迪讲话再长一些，您会发现又多次出现了我们字典中的模式，因此能够通过每个字典条目节省更多的文件空间。此外，对于更大的文件，还可能出现具有更大普遍性的模式，从而能够创建出效率更高的字典。
此外，文件压缩效率还取决于压缩程序使用的具体算法。有些程序能够在某些类型的文件中更好地寻找到模式，因此能更有效地压缩这些类型的文件。其他一些压缩程序在字典中又使用了字典，这使它们在压缩大文件时表现很好，但是在压缩较小的文件时效率不高。尽管这一类的所有压缩程序都基于同一个基本理念，但是它们的执行方式却各不相同。程序开发人员始终在尝试建立更好的压缩机制。
有损压缩和无损压缩
我们在上文中讨论的压缩类型称为无损压缩，因为您重新创建的文件与原始文件完全相同。所有无损压缩都基于这样一种理念：将文件变为“较小”的形式以利于传输或存储，并在另一方收到它后复原以便重新使用它。
有损压缩则与此大不相同。这些程序直接去除“不必要”的信息，对文件进行剪裁以使它变得更小。这种类型的压缩大量应用于减小位图图像的文件大小，因为位图图像的体积通常非常庞大。为了了解有损压缩的工作原理，让我们看看你的计算机如何对一张扫描的照片进行压缩。
对于此类文件，无损压缩程序的压缩率通常不高。尽管图片的大部分看起来都是相同的——例如，整个天空都是蓝色的——但是大部分像素之间都存在微小的差异。为了使图片变得更小同时不降低其分辨率，您必须更改某些像素的颜色值。如果图片中包含大量的蓝色天空，程序会挑选一种能够用于所有像素的蓝色。然后，程序重写该文件，所有天空像素的值都使用此信息。如果压缩方案选择得当，您不会注意到任何变化，但是文件大小会显着减小。
当然，对于有损压缩，在文件压缩后您无法将其复原成原始文件的样子。您必须接受压缩程序对原始文件的重新解释。因此，如果需要完全重现原来的内容（例如软件应用程序、数据库和总统就职演说），则不应该使用这种压缩形式。

‘陆’ C语言编写huffman编码（信息论基础教程里的上级作业）

#includestdio.h> #includestdlib.h> #includestring.h> #includemalloc.h> #define N 20
#define M 2*N-1
#define Min 1000 /*最小值*/ typedef struct
{
char ch; /*权值对应的字符*/ int weight; /*权值*/ int parent; /*双亲位置*/ int Lchild; /*左孩子位置*/ int Rchild; /*右孩子位置*/ }HTNode,Huffmantree[M+1];
char hc[N+1][N+1];
void OutputHuffmancode(Huffmantree ht, int n); void CrtHuffmancode(Huffmantree ht, int n); void OutputHuffmantree(Huffmantree ht,int n); void select(Huffmantree ht,int a,int *s1,int *s2) {
int i;
int c1=Min; int c2;
for(i=1;i=a;i++) {
if (ht.parent==0&&ht.weightc1) {
*s1=i; c1=ht.weight; } }
c2=Min;
for(i=1;i=a;i++) {
if (ht.parent==0&&(*s1!=i)&&c2>ht.weight) {
*s2=i; c2=ht.weight; }
} }
void CrtHuffmantree(Huffmantree ht,int w[],char elem[],int n)

{
int i; int m; int s1,s2; m=2*n-1;
ht=(HTNode *)malloc((m)*sizeof(HTNode));
for(i=1;i=n;i++) {
ht.ch=elem[i-1]; ht.weight=w[i-1]; ht.parent=0; ht.Lchild=0; ht.Rchild=0; }
for(i=n+1;i=m;i++) {
ht.ch='\0'; ht.weight=0; ht.parent=0; ht.Lchild=0; ht.Rchild=0; }
/*初始化完毕*/
for(i=n+1;i=m;i++) {
select( ht,i-1,&s1,&s2); /*返回最小值和次小值的位置*/ ht.weight=ht[s1].weight+ht[s2].weight; ht[s1].parent=i;
ht[s2].parent=i; ht.Lchild=s1;
ht.Rchild=s2;/*建立树完毕*/ }
OutputHuffmantree( ht,m);
printf("now begin crthuffman code\n"); CrtHuffmancode( ht, n);
printf("crthuffman code end\n"); OutputHuffmancode(ht, n); }
void OutputHuffmantree(Huffmantree ht,int n)
{
int i;
printf("\nnumber---weight---parent---Lchild---Rchild---huffman char\n \n");

for(i=1;i=n;i++)
printf("%d\t%d\t%d\t%d\t%d\t%c\n",i,ht.weight,ht.parent,ht.Lchild,ht.Rchild,ht.ch); }
void CrtHuffmancode(Huffmantree ht, int n) /*建立编码*/ {
int i,c,p; int start; char *cd;
cd=(char *) malloc((n+1)*sizeof(char)); memset(cd,'\0',sizeof(cd));
for(i=1;i=n;i++) {
start=n;
cd[start]='\0';
c=i;
p=ht.parent; while(p!=0) {
start--;
if(ht[p].Lchild==c) cd[start]='0'; else
cd[start]='1';
c=p;
p=ht[p].parent; }
//cd[start] = '\0';
printf("cd is %s\n start is %d\n", cd+start, start);
sprintf(hc, "%s", cd+start); /*将已存在的编码复制到code中*/ } free(cd); }
void OutputHuffmancode(Huffmantree ht,int n) {
int i;
printf("\nweight_char---weight---huffmancode\n \n"); for(i=1;i=n;i++)
printf(" %c\t%4d\t%s\n",ht.ch,ht.weight,hc); }
int main()

{
int n = 6;/*记录了权值个数*/ Huffmantree hfm;
int w[] = {45,13,12,16,9,5}; char elem[] = {'a','b','c','d','e','f'};
CrtHuffmantree( hfm, w,elem, n); return 0; }

‘柒’ 霍夫曼 解压缩

哈夫曼编码(Huffman Coding)是一种编码方式，以哈夫曼树—即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。 在计算机信息处理中，“哈夫曼编码”是一种一致性编码法（又称"熵编码法"），用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。这种方法是由David.A.Huffman发展起来的。 例如，在英文中，e的出现概率很高，而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时，e极有可能用一个位(bit)来表示，而z则可能花去25个位（不是26）。用普通的表示方法时，每个英文字母均占用一个字节（byte），即8个位。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

本文描述在网上能够找到的最简单，最快速的哈夫曼编码。本方法不使用任何扩展动态库，比如STL或者组件。只使用简单的C函数，比如：memset，memmove，qsort，malloc，realloc和memcpy。
因此，大家都会发现，理解甚至修改这个编码都是很容易的。

背景
哈夫曼压缩是个无损的压缩算法，一般用来压缩文本和程序文件。哈夫曼压缩属于可变代码长度算法一族。意思是个体符号（例如，文本文件中的字符）用一个特定长度的位序列替代。因此，在文件中出现频率高的符号，使用短的位序列，而那些很少出现的符号，则用较长的位序列。
编码使用
我用简单的C函数写这个编码是为了让它在任何地方使用都会比较方便。你可以将他们放到类中，或者直接使用这个函数。并且我使用了简单的格式，仅仅输入输出缓冲区，而不象其它文章中那样，输入输出文件。
bool CompressHuffman(BYTE *pSrc, int nSrcLen, BYTE *&pDes, int &nDesLen);
bool DecompressHuffman(BYTE *pSrc, int nSrcLen, BYTE *&pDes, int &nDesLen);
要点说明
速度
为了让它(huffman.cpp)快速运行，我花了很长时间。同时，我没有使用任何动态库，比如STL或者MFC。它压缩1M数据少于100ms（P3处理器，主频1G）。
压缩
压缩代码非常简单，首先用ASCII值初始化511个哈夫曼节点：
CHuffmanNode nodes[511];
for(int nCount = 0; nCount < 256; nCount++)
nodes[nCount].byAscii = nCount;
然后，计算在输入缓冲区数据中，每个ASCII码出现的频率：
for(nCount = 0; nCount < nSrcLen; nCount++)
nodes[pSrc[nCount]].nFrequency++;
然后，根据频率进行排序：
qsort(nodes, 256, sizeof(CHuffmanNode), frequencyCompare);
现在，构造哈夫曼树，获取每个ASCII码对应的位序列：
int nNodeCount = GetHuffmanTree(nodes);
构造哈夫曼树非常简单，将所有的节点放到一个队列中，用一个节点替换两个频率最低的节点，新节点的频率就是这两个节点的频率之和。这样，新节点就是两个被替换节点的父节点了。如此循环，直到队列中只剩一个节点（树根）。
// parent node
pNode = &nodes[nParentNode++];
// pop first child
pNode->pLeft = PopNode(pNodes, nBackNode--, false);
// pop second child
pNode->pRight = PopNode(pNodes, nBackNode--, true);
// adjust parent of the two poped nodes
pNode->pLeft->pParent = pNode->pRight->pParent = pNode;
// adjust parent frequency
pNode->nFrequency = pNode->pLeft->nFrequency + pNode->pRight->nFrequency;
这里我用了一个好的诀窍来避免使用任何队列组件。我先前就直到ASCII码只有256个，但我分配了511个(CHuffmanNode nodes[511])，前255个记录ASCII码，而用后255个记录哈夫曼树中的父节点。并且在构造树的时候只使用一个指针数组(ChuffmanNode *pNodes[256])来指向这些节点。同样使用两个变量来操作队列索引(int nParentNode = nNodeCount;nBackNode = nNodeCount –1)。
接着，压缩的最后一步是将每个ASCII编码写入输出缓冲区中：
int nDesIndex = 0;
// loop to write codes
for(nCount = 0; nCount < nSrcLen; nCount++)
{
*(DWORD*)(pDesPtr+(nDesIndex>>3)) |=
nodes[pSrc[nCount]].dwCode << (nDesIndex&7);
nDesIndex += nodes[pSrc[nCount]].nCodeLength;
}
(nDesIndex>>3): >>3 以8位为界限右移后到达右边字节的前面
(nDesIndex&7): &7 得到最高位.
注意：在压缩缓冲区中，我们必须保存哈夫曼树的节点以及位序列，这样我们才能在解压缩时重新构造哈夫曼树（只需保存ASCII值和对应的位序列）。
解压缩
解压缩比构造哈夫曼树要简单的多，将输入缓冲区中的每个编码用对应的ASCII码逐个替换就可以了。只要记住，这里的输入缓冲区是一个包含每个ASCII值的编码的位流。因此，为了用ASCII值替换编码，我们必须用位流搜索哈夫曼树，直到发现一个叶节点，然后将它的ASCII值添加到输出缓冲区中：
int nDesIndex = 0;
DWORD nCode;
while(nDesIndex < nDesLen)
{
nCode = (*(DWORD*)(pSrc+(nSrcIndex>>3)))>>(nSrcIndex&7);
pNode = pRoot;
while(pNode->pLeft)
{
pNode = (nCode&1) ? pNode->pRight : pNode->pLeft;
nCode >>= 1;
nSrcIndex++;
}
pDes[nDesIndex++] = pNode->byAscii;
}

‘捌’ 霍夫曼算法

霍夫曼算法的步骤是这样的：

·从各个节点中找出最小的两个节点，给它们建一个父节点，值为这两个节点之和。
·然后从节点序列中去除这两个节点，加入它们的父节点到序列中。

重复上面两个步骤，直到节点序列中只剩下唯一一个节点。这时一棵最优二叉树就已经建成了，它的根就是剩下的这个节点。

仍以上面的例子来看霍夫曼树的建立过程。
最初的节点序列是这样的：
a(6) b(15) c(2) d(9) e(1)

把最小的c和e结合起来
| (3)
a(6) b(15) d(9) +------+------+
| |
c e

不断重复，最终得到的树是这样的：

根
|
+-----33-----+
| |
15 +----18----+
| |
9 +------9-----+
| |
6 +--3--+
| |
2 1

这时各个字符的编码长度和前面我们说过的方法得到的编码长度是相同的，因而文件的总长度也是相同的： 3*6 + 1*15 + 4*2 + 2*9 + 4*1 = 63

考察霍夫曼树的建立过程中的每一步的节点序列的变化：

6 15 2 9 1
6 15 9 3
15 9 9
15 18
33

下面我们用逆推法来证明对于各种不同的节点序列，用霍夫曼算法建立起来的树总是一棵最优二叉树：

对霍夫曼树的建立过程运用逆推法：
当这个过程中的节点序列只有两个节点时（比如前例中的15和18），肯定是一棵最优二叉树，一个编码为0，另一个编码为1，无法再进一步优化。
然后往前步进，节点序列中不断地减少一个节点，增加两个节点，在步进过程中将始终保持是一棵最优二叉树，这是因为：
1.按照霍夫曼树的建立过程，新增的两个节点是当前节点序列中最小的两个，其他的任何两个节点的父节点都大于（或等于）这两个节点的父节点，只要前一步是最优二叉树，其他的任何两个节点的父节点就一定都处在它们的父节点的上层或同层，所以这两个节点一定处在当前二叉树的最低一层。
2.这两个新增的节点是最小的，所以无法和其他上层节点对换。符合我们前面说的最优二叉树的第一个条件。
3.只要前一步是最优二叉树，由于这两个新增的节点是最小的，即使同层有其他节点，也无法和同层其他节点重新结合，产生比它们的父节点更小的上层节点来和同层的其他节点对换。它们的父节点小于其他节点的父节点，它们又小于其他所有节点，只要前一步符合最优二叉树的第二个条件，到这一步仍将符合。

这样一步步逆推下去，在这个过程中霍夫曼树每一步都始终保持着是一棵最优二叉树。

由于每一步都从节点序列中删除两个节点，新增一个节点，霍夫曼树的建立过程共需 (原始节点数 - 1) 步，所以霍夫曼算法不失为一种精巧的编码式压缩算法。

附：对于 huffman 树，《计算机程序设计艺术》中有完全不同的证明，大意是这样的：
1．二叉编码树的内部节点（非叶子节点）数等于外部节点（叶子节点）数减1。
2．二叉编码树的外部节点的加权路径长度（值乘以路径长度）之和，等于所有内部节点值之和。（这两条都可以通过对节点数运用数学归纳法来证明，留给大家做练习。）
3．对 huffman 树的建立过程运用逆推，当只有一个内部节点时，肯定是一棵最优二叉树。
4．往前步进，新增两个最小的外部节点，它们结合在一起产生一个新的内部节点，当且仅当原先的内部节点集合是极小化的，加入这个新的内部节点后仍是极小化的。（因为最小的两个节点结合在一起，并处于最低层，相对于它们分别和其他同层或上层节点结合在一起，至少不会增加加权路径长度。）
5．随着内部节点数逐个增加，内部节点集合总维持极小化。

2．实现部分
如果世界上从没有一个压缩程序，我们看了前面的压缩原理，将有信心一定能作出一个可以压缩大多数格式、内容的数据的程序，当我们着手要做这样一个程序的时候，会发现有很多的难题需要我们去一个个解决，下面将逐个描述这些难题，并详细分析 zip 算法是如何解决这些难题的，其中很多问题带有普遍意义，比如查找匹配，比如数组排序等等，这些都是说不尽的话题，让我们深入其中，做一番思考。