导航:首页 > 编程语言 > java哈夫曼压缩算法

java哈夫曼压缩算法

发布时间:2021-02-23 17:38:59

1. 萌新求教:我的java哈夫曼算法输出为什么少一位

1、局部代码不太好找原因,不过看结果不是少一位的事,简单画了一下

2、输出

g:0000

a:0001

h:001

f:01

b:10

e:110

c:1110

d:1111

2. java哈夫曼编码压缩文件的思想

一.模型表示:
计算机使用数字代码来存储字符,ASC II码是最常用的编码。一个ASC II码值占一个字节(8个二进制位),其最高位(b7)用作奇偶校验位,共128个。要对一个文本文件进行压缩,就是要对文件内的字符重新编码,使出现次数较多的字符用较短的编码存储,而出现次数少的字符则采用相对较长的编码存储,最终使压缩后整个文件的大小小于原文件。
这里采用哈夫曼编码方式来对每个字符重新编码,因为哈夫曼树具有最小带权路径长度的性质,能够生成用于压缩的二进制前缀码。程序使用的 “静态统计模型”,也就是说在编码前统计要编码的信息中所有字符的出现频率,字符的出现频率即为字符的权,然后根据统计出的信息建立编码树,进行编码。利用所得的编码生成压缩文件。由于采用的是“静态统计模型”,在压缩文件里必须保存统计出的结果以便解码时构造相同的编码树,或者直接保存编码树本身。
在解压缩时,首先从文件头读入保存的编码信息,从而对后续的编码解码,还原成ASCII的形式,生成与原文相同的文件。

二.概要设计:
由于一棵有n个叶子结点的哈夫曼树共有2n-1个结点,考虑到程序的执行效率,可以将二叉树存放在连续空间里(静态链表),空间的每个结点内仍有左子树、右子树、双亲等指针,以便译码和解码。即存储在一个大小为2n-1的一维数组中,每个结点的结构为:
struct HNode
{
char elem; //保存结点所表示的字符(主要用于译码时)
unsigned long weight; //保存结点的权值,对于叶子,即为字符的出现次数
int parent, lchild, rchild; //保存结点的双亲,左右孩子的位置

3. 哈夫曼压缩算法的内容是什么

哈夫曼压缩算法编码是无损压缩当中最好的方法。它使用预先二进制描述来替换每个符号,长度由特殊符号出现的频率决定。常见的符号需要很少的位来表示,而不常见的符号需要很多为来表示。
哈夫曼算法在改变任何符号二进制编码引起少量密集表现方面是最佳的。然而,它并不处理符号的顺序和重复或序号的序列。
哈夫曼压缩算法之原理
我不打算探究哈夫曼编码的所有实际的细节,但基本的原理是为每个符号找到新的二进制表示,从而通常符号使用很少的位,不常见的符号使用较多的位。
简短的说,这个问题的解决方案是为了查找每个符号的通用程度,我们建立一个未压缩数据的柱状图;通过递归拆分这个柱状图为两部分来创建一个二叉树,每个递归的一半应该和另一半具有同样的权(权是∑NK =1符号数k, N是分之中符号的数量,符号数k是符号k出现的次数)
这棵树有两个目的:
1. 编码器使用这棵树来找到每个符号最优的表示方法
2. 解码器使用这棵树唯一的标识在压缩流中每个编码的开始和结束,其通过在读压缩数据位的时候自顶向底的遍历树,选择基于数据流中的每个独立位的分支,一旦一个到达叶子节点,解码器知道一个完整的编码已经读出来了。
哈夫曼编码器生成哈夫曼树
压缩后的数据流是24位(三个字节),原来是80位(10个字节)。当然,我应该存储哈夫曼树,这样解码器就能够解码出对应的压缩流了,这就使得该例子中的真正数据流比输入的流数据量大。这是相对较短的数据上的副作用。对于大数据量来说,上面的哈夫曼树就不占太多比例了
最终的压缩数据流
解码的时候,从上到下遍历树,为压缩的流选择从左/右分支,每次碰到一个叶子节点的时候,就可以将对应的字节写到解压输出流中,然后再从根开始遍历。
哈夫曼压缩算法之实现
哈夫曼编码器可以在基本压缩库中找到,其是非常直接的实现。
这个实现的基本缺陷是:
1. 慢位流实现
2. 相当慢的解码(比编码慢)
3. 最大的树深度是32(编码器在任何超过32位大小的时候退出)。如果我不是搞错的话,这是不可能的,除非输出的数据大于232字节。
另一方面,这个实现有几个优点:
1. 哈夫曼树以一个紧密的形式每个符号要求12位(对于8位的符号)的方式存储,这意味着最大的头为384。
2. 编码相当容易理解
哈夫曼编码在数据有噪音的情况(不是有规律的,例如RLE)下非常好,这中情况下大多数基于字典方式的编码器都有问题。
以上就是对哈夫曼压缩算法的简单介绍。
另外网络文库也有《哈夫曼压缩算法》你可以看参考资料
希望对您有帮助

4. 用java实现哈夫曼编码

只要自己再加个类Tree就可以了。
代码如下:

public class Tree {
double lChild, rChild, parent;
public Tree (double lChild, double rChild, double parent) {
this.lChild = lChild;
this.rChild = rChild;
this.parent = parent;
}
public double getLchild() {
return lChild;
}
public void setLchild(double lChild) {
this.lChild = lChild;
}
public double getRchild() {
return rChild;
}
public void setRchild(double rChild) {
this.rChild = rChild;
}
public double getParents() {
return parent;
}
public void setParents(double root) {
this.parent = root;
}

}

5. 求救用java实现哈夫曼压缩解压算法 小妹非常感谢

这是C的 仅供参考

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MAX_SINGLECODE_LEN 10 //单个字符最大码长
#define MAX_STRING_LEN 1000 //要编码的字符串的最大长度
#define MAX_CODESTRING_LEN 10000 //产生的二进制码的最大长度
#define MAX_WORDS 1000 //要编码的字符串中字符种数最大值
#define END_TREE 30000 //树部分存储的结束符
#define PATH_LEN 50 //路径串最大长度

/*****哈夫曼树结构定义*****/
typedef struct Huffmantree
{
char ch; //字符部分
int weight; //结点权值
int mark; //标记是否加入树中
struct Huffmantree *parent,*lchild,*rchild,*next;
}HTNode,*LinkTree;

/*****编码字典结构定义*****/
typedef struct
{
char ch; //字符部分
char code[MAX_SINGLECODE_LEN]; //编码部分
}CodeDictionary;

/*********函数声明*********/
LinkTree setWeight(char *);
LinkTree sortNode(LinkTree);
LinkTree createHTree(LinkTree);
void codeHTree(LinkTree,CodeDictionary *);
void decodeHTree(LinkTree,char *,char *);
void deleteNode(LinkTree);
void compressString(char *s,CodeDictionary *,char *);
void readFile(char *);
void writeFile(char *);
void readCode(LinkTree,char *);
void writeCode(LinkTree,char *);
void menu();

/**
*主函数
*输入:空
*返回:空
*/
void main(void)
{
char choice; //菜单选择变量
char string[MAX_STRING_LEN]; //保存从文件中读取的内容
LinkTree temp; //保存赋了权值的表
LinkTree ht; //保存排序后的表
LinkTree ht,temp; //表备份
LinkTree htree; //保存哈夫曼树
LinkTree ptr=NULL;
CodeDictionary codedictionary[MAX_WORDS];//编码字典
char codestring[MAX_CODESTRING_LEN]; //保存0-1形的代码串
char codestring2[MAX_CODESTRING_LEN];//保存0-1形的代码串
LinkTree ht2; //保存读取的树
LinkTree htree2; //保存排序后的表
char filestring[MAX_STRING_LEN]; //解码后要写入文件中的内容

if((ht2=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建链表的头结点
{
printf("内存不足!");
getch();
exit(0);
}
ht2->next=NULL;

while(1)
{
menu(); //调入主菜单
choice=getch(); //读入用户选项
switch(choice) //判断用户选择
{
case 'c':
case 'C':
printf("\n您选择了压缩文件模式:\n\n");
readFile(string); //读取要编码的文件(字符串)
temp=setWeight(string); //得到有权值的表
temp=setWeight(string);
ht=sortNode(temp); //按权值排序后的表
ht=sortNode(temp); //用于记录解码树
htree=createHTree(ht); //得到哈夫曼树
codeHTree(htree,codedictionary);//哈夫曼编码
compressString(string,codedictionary,codestring);//压缩为0-1码
writeCode(ht,codestring); //将解码树和0-1码保存
deleteNode(htree); //释放空间*/
break;
case 'u':
case 'U':
printf("您选择了解压缩文件模式:\n\n");
readCode(ht2,codestring2); //读取要解码的0-1码
htree2=createHTree(ht2); //得到哈夫曼树
codeHTree(htree2,codedictionary);//哈夫曼编码
decodeHTree(htree2,codestring2,filestring); //解码
writeFile(filestring); //将解码文件保存
deleteNode(htree2); //释放空间
break;
case 'e':
case 'E':
exit(0); //退出程序
}
}
}/**
*整理输入的字符串,求出每个字符在数组中出现的次数,作为权值
*输入:(字符型指针)字符串的地址
*返回:(哈夫曼结点指针)含权链表的首地址
*/
LinkTree setWeight(char *string)
{
int i=0; //文件字符串下标
LinkTree tree; //头指针
LinkTree ptr,beforeptr; //创建指针与其前驱
HTNode *node;

if((tree=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建链表的头结点
return NULL;
tree->next=NULL;

for(i=0;string[i]!='\0';i++)
{
ptr=tree;
beforeptr=tree;

if((node=(HTNode *)malloc(sizeof(HTNode)))==NULL)
return NULL;
node->next=NULL;
node->parent=NULL;
node->lchild=NULL;
node->rchild=NULL;
node->mark=0;
node->ch=string[i];
node->weight=1;

if(tree->next==NULL) //如果是第一个非头结点
tree->next=node;
else
{
ptr=tree->next;
while(ptr&&ptr->ch!=node->ch) //查找相同字符
{
ptr=ptr->next;
beforeptr=beforeptr->next;
}
if(ptr&&ptr->ch==node->ch) //如果链表中某结点的字符与新结点的字符相同
{
ptr->weight++; //将该结点的权加一
free(node);
}
else //将新结点插入链表后
{
node->next=beforeptr->next;
beforeptr->next=node;
}
}
}
return tree; //返回头指针
}

/**
*将整理完的字符串(带权链表)按出现次数从小到大的顺序排列
*输入:(哈夫曼结点指针)要排序的表头地址
*返回:(哈夫曼结点指针)排序后的表头地址
*/
LinkTree sortNode(LinkTree tree)
{
LinkTree head; //头指针
LinkTree ph,beforeph; //创建指针及其前驱
LinkTree pt;

if((head=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建新链表的头结点
return NULL;
head->next=NULL;

ph=head;
beforeph=head;

while(tree->next)
{
pt=tree->next; //取被*作链表的头结点
tree->next=pt->next;
pt->next=NULL;

ph=head->next;
beforeph=head;

if(head->next==NULL)
head->next=pt; //创建当前*作链表头结点
else
{
while(ph&&ph->weight<pt->weight) //将被*作结点插入相应位置
{
ph=ph->next;
beforeph=beforeph->next;
}
pt->next=beforeph->next;
beforeph->next=pt;
}
}
free(tree);
return head; //返回排序后的头指针
}

/**
*用排完序的字符串建立哈夫曼树
*输入:(哈夫曼结点指针)要建立哈夫曼树的地址
*返回:(哈夫曼结点指针)建立后的哈夫曼树地址
*/
LinkTree createHTree(LinkTree tree)
{
LinkTree p,q,beforep;
HTNode *newnode;

for(p=tree->next,q=p->next;p!=NULL&&q!=NULL;p=tree->next,q=p->next)
//p、q初值为头结点后的两个结点,即最小权结点
{
tree->next=q->next;
q->next=NULL;
p->next=NULL;

if((newnode=(HTNode *)malloc(sizeof(HTNode)))==NULL)
//申请新结点作为哈夫曼树的中间结点
return NULL;
newnode->next=NULL;
newnode->mark=0;

newnode->lchild=p; //取链表头结点后的两个结点作为新结点的左、右孩子
newnode->rchild=q;
p->parent=newnode;
q->parent=newnode;
newnode->weight=p->weight+q->weight; //权值相加

p=tree->next;
beforep=tree;

if(p!=NULL&&p->weight>=newnode->weight)
{
newnode->next=beforep->next; //将新结点插入原链表的相应位置
beforep->next=newnode;
}
else
{
while(p!=NULL&&p->weight<newnode->weight)
{
p=p->next;
beforep=beforep->next;
}
newnode->next=beforep->next;
beforep->next=newnode;
}
}
return (tree->next);
}

/**
*对哈夫曼树进行编码
*输入:(哈夫曼结点指针)要编码的哈夫曼树地址
* (编码字典类型指针)存放字典的首地址
*返回:空
*/
void codeHTree(LinkTree tree,CodeDictionary *codedictionary)
{
int index=0,k=0;
char code[MAX_SINGLECODE_LEN]; //用于统计每个字符的哈夫曼编码
LinkTree ptr=tree; //从树的根结点开始

if(ptr==NULL)
{
printf("要压缩的文件是空的!\n");
exit(0);
}
else
{
while(ptr->lchild&&ptr->rchild&&ptr->mark==0)
{
while(ptr->lchild&&ptr->lchild->mark==0)
{
code[index++]='0'; //左支路编码为0
ptr=ptr->lchild;
if(!ptr->lchild&&!ptr->rchild) //如果没有左右孩子,即叶子结点
{
ptr->mark=1; //作标记,表明该字符已被编码
code[index]='\0'; //编码0-1字符串结束
codedictionary[k].ch=ptr->ch;//给字典赋字符值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//给字典赋码值
codedictionary[k].code[index]='\0';
k++;
ptr=tree; //指针复位
index=0;
}
}
if(ptr->rchild&&ptr->rchild->mark==0)
{
ptr=ptr->rchild;
code[index++]='1'; //右支路编码为1
}
if(!ptr->lchild&&!ptr->rchild) //如果没有左右孩子,即叶子结点
{
ptr->mark=1;
code[index++]='\0';
codedictionary[k].ch=ptr->ch; //给字典赋字符值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//给字典赋码值
codedictionary[k].code[index]='\0';
k++;
ptr=tree;
index=0;
}
if(ptr->lchild->mark==1&&ptr->rchild->mark==1)//如果左右孩子都已标记
{
ptr->mark=1;
ptr=tree;
index=0;
}
}
}
printf("\n");
}

/**
*解码,即将0-1码转化为字符串
*输入:(哈夫曼结点指针)编码树的地址
* (字符型指针)要解码的0-1字符串地址
* (字符型指针)解码后的字符串地址
*返回:空
*/
void decodeHTree(LinkTree tree,char *code,char *filestring)
{
int i=0,j=0,k=0;
char *char0_1;
LinkTree ptr=tree;
char0_1=(char *)malloc(MAX_SINGLECODE_LEN); //此数组用于统计输入的0-1序列

printf("预览解压后的字符:\n");
for(j=0,ptr=tree;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j=0,ptr=tree)
{
for(j=0;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j++,i++)
{
if(code[i]=='0')
{
ptr=ptr->lchild;
char0_1[j]='0';
}
if(code[i]=='1')
{
ptr=ptr->rchild;
char0_1[j]='1';
}
}
if(!ptr->lchild&&!ptr->rchild)
{
printf("%c",ptr->ch); //显示解压后的字符
filestring[k++]=ptr->ch; //将字符逐一保存到字符串里
}
if(code[i]=='\0'&&ptr->lchild&&ptr->rchild)
{
char0_1[j]='\0';
printf("\n没有与最后的几个0-1序列:%s相匹配的字符!\n",char0_1);
return;
}
}
printf("\n\n");
filestring[k]='\0';
free(char0_1);
}

/**
*释放哈夫曼树所占用的空间
*输入:(哈夫曼结点指针)要释放的结点地址
*返回:空
*/
void deleteNode(LinkTree tree)
{
LinkTree ptr=tree;
if(ptr)
{
deleteNode(ptr->lchild);
deleteNode(ptr->rchild);
free(ptr);
}
}

/**
*将整个字符串转化为0-1的字符串
*输入:(字符型指针)待转化的字符串首地址
* (编码字典类型指针)字典首地址
* (字符型指针)接收0-1码串的首地址
*返回:空
*/
void compressString(char *string,CodeDictionary *codedictionary,char *codestring)
{
int i=0,j=0,k=0,m;

while(string[i]) //整个文件字符串没结束时
{
while(string[i]!=codedictionary[j].ch&&j<MAX_WORDS)
//找与对应字符相同的字符
j++;
if(string[i]==codedictionary[j].ch) //如果找到与对应字符相同的字符
for(m=0;codedictionary[j].code[m];m++,k++)
codestring[k]=codedictionary[j].code[m];
j=0; //字典复位
i++;
}
codestring[k]='\0';
}

/**
*把指定文件读到字符串中
*输入:(字符型指针)待接收文件的字符串地址
*返回:空
*/
void readFile(char *string)
{
FILE *fp;
int i;
char ch; //记录读入的字符
char path[PATH_LEN]; //文本文件的读路径

printf("请输入要压缩的文本文件地址:(无需扩展名)");
gets(path);
if((fp=fopen(strcat(path,".txt"),"r"))==NULL)
{
printf("\n路径不正确!\n");
getch();
return;
}

ch=fgetc(fp);
for(i=0;ch!=EOF;i++)
{
string[i]=ch;
ch=fgetc(fp);
}
string[i]='\0';
fclose(fp);
}

/**
*保存编码后的解码树和字符串
*输入:(哈夫曼结点指针)解码树的地址
* (字符型指针)要保存的0-1码串首地址
*返回:空
*/
void writeCode(LinkTree tree,char *string)
{
FILE *fp;
int i;
int weight; //记录写入的权值
char ch; //记录写入的字符
LinkTree p;
char path[PATH_LEN]; //0-1码文件的写路径

printf("请输入压缩后的保存路径及文件名:(无需扩展名)");
gets(path);
if((fp=fopen(strcat(path,".yxy"),"w+"))==NULL)
{
printf("\n文件路径出错!\n");
getch();
return;
}
p=tree->next;

/*解码树部分写入文件前部分*/
do
{
ch=p->ch;
weight=p->weight;
fprintf(fp,"%c%d",ch,weight);
p=p->next;
}while(p);
fprintf(fp,"%c%d",'^',END_TREE);

fseek(fp,sizeof(char),1); //空出区分位

/*0-1码写入文件后部分*/
for(i=0;string[i];i++)
{
ch=string[i];
fputc(ch,fp);
}
printf("\n压缩成功!\n");
getch();
fclose(fp);
}

/**
*读取编码后的0-1字符串
*输入:(哈夫曼结点指针)解码树的地址
* (字符型指针)要接收的0-1码串首地址
*返回:空
*/
void readCode(LinkTree tree,char *string)
{

FILE *fp;
int i;
int weight; //记录读入的权值
char ch; //记录读入的字符
LinkTree ptr,beforeptr;
char path[PATH_LEN]; //0-1码文件的读路径

printf("请输入要解压的文件路径及文件名:(无需扩展名)");
gets(path);
if((fp=fopen(strcat(path,".yxy"),"r"))==NULL)
{
printf("\n文件路径出错!\n");
getch();
return;
}
beforeptr=tree;

/*从文件前部分读出解码树*/
fscanf(fp,"%c%d",&ch,&weight);
while(weight!=END_TREE)
{
if((ptr=(LinkTree)malloc(sizeof(HTNode)))==NULL)
{
printf("内存不足!");
getch();
exit(1); //错误出口
}
ptr->ch=ch;
ptr->weight=weight;
ptr->lchild=NULL;
ptr->rchild=NULL;
ptr->parent=NULL;
ptr->mark=0;
beforeptr->next=ptr;
beforeptr=ptr;
fscanf(fp,"%c%d",&ch,&weight);
}
beforeptr->next=NULL;

fseek(fp,sizeof(char),1); //文件指针定位

/*从文件后部分读出0-1码*/
ch=fgetc(fp);
for(i=0;ch!=EOF;i++)
{
string[i]=ch;
ch=fgetc(fp);
}
string[i]='\0';
fclose(fp);
}

/**
*保存解码后的文件
*输入:(字符型指针)解码后的字符串地址
*返回:空
*/
void writeFile(char *string)
{
FILE *fp;
char ch; //记录写入的字符
int i;
char path[PATH_LEN]; //文本文件的写路径

printf("请输入解压后的保存路径及文件名:(无需扩展名)");
gets(path);
if((fp=fopen(strcat(path,".txt"),"w+"))==NULL)
{
printf("\n文件路径出错!\n");
getch();
return;
}

for(i=0;string[i];i++)
{
ch=string[i];
fputc(ch,fp);
}
printf("\n解压成功!\n");
getch();
fclose(fp);
}

/**
*显示主菜单
*输入:空
*返回:空
*/
void menu()
{
printf("\n\n\n\n\n\n");
printf("\t\t -----** 欢迎使用WINYXY压缩工具 **-----");
printf("\n\n\n");
printf("\t\t\t\t<c> 压 缩\n\n");
printf("\t\t\t\t<u> 解 压\n\n");
printf("\t\t\t\t<e> 退 出\n\n");
}

6. 您好 关于哈夫曼压缩编码 用java的话不知道怎样实现按位读入和按位写入 求指教

按位读入:
String[] huffmanTable = huffmanTree.generateHuffmanTable();
BufferedInputStream in = new BufferedInputStream(new FileInputStream(inputFile));

StringBuilder outputStringBuffer = new StringBuilder(8 + 255);

while (true) {
// 这里读入的就是个
int origin = in.read();
if (origin == FileSymbol.END_OF_FILE){
break;
} else {
//get huffman code of origin byte from a table
StringBuilder codeString = new StringBuilder(huffmanTable[origin]);
outputStringBuffer.append(codeString);
while (outputStringBuffer.length() > 8 ) {
//convert every eight code to a byte and write
out.write(Short.parseShort(outputStringBuffer.substring(0, 8), 2));
outputStringBuffer.delete(0, 8);
}
}
}

按位写入:
//read a byte and convert to code, adding prefix '0' to reach length - 8
// 重点就是这个内置的API,可以把一个Int按转为成包含01的字符串
String codeString = Integer.toBinaryString(code);
//前置的零无法自动补足,要自己添加
if (codeString.length() < 8) {
outputStringBuffer.append(zeroString[codeString.length()]);
}
outputStringBuffer.append(codeString);

P.S.我定义了这个数组为了加快解压速度,因为
String[] zeroString = new String[] {
"00000000",
"0000000",
"000000",
"00000",
"0000",
"000",
"00",
"0",
};

-------------------------------------------------------------
之后我又想了下。
上面是我自己的PJ,压缩和解码的缓冲区用的是StringBuilder,才会有类似下面这些方法:
out.write(Short.parseShort(outputStringBuffer.substring(0, 8), 2));
outputStringBuffer.delete(0, 8);
String codeString = Integer.toBinaryString(code);

不知道你说的“按位读入”和“按位写入”,指代的具体是什么?逐位操作是效率很低的方法。纯位操作,应该指用long做缓冲区,用移位的方式编解码,思路应该是:
long buffer;
int bufferLength = 0;
while ( 文件未读完 ) {
// read byte
byte b = in.readByte();
// get code
int code = HuffmanCode[b];
int codeLength = HuffmanCodeLength[b];
// add to buffer
buffer = b | (buffer << codeLength);
bufferLength += codeLength;
// write from buffer
while (bufferLength > 8) {
// 写buffer最前面的8位
out.writeByte((int)(buffer >>> (bufferLength - 8)))

// 舍弃buffer最前面的8位
bufferLength -= 8;
buffer &= (1 << bufferLength - 1) ;
}
}
和上面思路一样,不过用long代替StringBuilder做缓冲区。不知道这个算不算按位读入和按位写入

7. 哈夫曼编码的压缩实现

压缩代码非常简单,首先用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;
}

8. 请专家解释:WinRAR的压缩算法是基于哈夫曼算法的吗

注:哈夫曼和LZSS算法不是同一种算法,先用哈夫曼再用LZSS算法压缩后会发现经哈夫曼压缩后再用LZSS压缩文件会变大,具体原因不明
LZSS原理:
把编码位置置于输入数据流的开始位置。
在前向缓冲器中查找窗口中最长的匹配串
① Pointer :=匹配串指针。
② Length :=匹配串长度。
判断匹配串长度Length是否大于等于最小匹配串长度(MIN_LENGTH) ,
如果“是”:输出指针,然后把编码位置向前移动Length个字符。
如果“否”:输出前向缓冲存储器中的第1个字符,然后把编码位置向前移动一个字符。
如果前向缓冲器不是空的,就返回到步骤2。
例:编码字符串如表03-05-3所示,编码过程如表03-05-4所示。现说明如下:
“步骤”栏表示编码步骤。
“位置”栏表示编码位置,输入数据流中的第1个字符为编码位置1。
“匹配”栏表示窗口中找到的最长的匹配串。
“字符”栏表示匹配之后在前向缓冲存储器中的第1个字符。
“输出”栏的输出为:
① 如果匹配串本身的长度Length >= MIN_LENGTH,输出指向匹配串的指针,格式为(Back_chars, Chars_length)。该指针告诉译码器“在这个窗口中向后退Back_chars个字符然后拷贝Chars_length个字符到输出”。
② 如果匹配串本身的长度Length >= MIN_LENGTH,则输出真实的匹配串。
表:输入数据流
位置 1234567891011
字符 AABBCBBAABC
表:编码过程(MIN_LENGTH = 2)
步骤位置匹配串输出
11--A
22AA
33-- B
44BB
55--C
66B B(3,2)
78 A A B(7,3)
811CC

9. 求助:用java实现哈夫曼编码压缩与解压缩算法。

你好,由于内容比较多,先概述一下先。如图所示,为我写的一个压缩软件,原理是利用哈弗曼算法实现的。我将资料整理好稍后就发到你邮箱,但在这里简要说明一下代码。

请看我的空间

http://hi..com/%D2%B6%BF%C6%C1%BC/blog

中的文章共5篇(太长了)

http://hi..com/%D2%B6%BF%C6%C1%BC/blog/item/93c35517bb528146f2de32fd.html

1.HuffmanTextEncoder类完成压缩功能,可直接运行,压缩测试用文本文件。

2.HuffmanTextDecoder类完成解压缩功能,可直接运行,解压缩压缩后的文本文件。

3.BitReader,工具类,实现对BufferedInputStream的按位读取。

4.BitWriter,工具类,实现按位写入的功能。该类来自网络。

5.MinHeap<T>,模板工具类,实现了一个最小堆。生成Huffman树时使用。

阅读全文

与java哈夫曼压缩算法相关的资料

热点内容
音频工具酷 浏览:837
三规合一大数据 浏览:863
微信群里三方视频教程 浏览:348
荣耀6plus系统更新 浏览:696
苹果手机的照片怎么传到安卓手机 浏览:854
怎么卸载系统自带软件 浏览:869
发布关于运用大数据 浏览:400
vb6判断文件后缀 浏览:549
6s升级ios10电信4g慢 浏览:732
网络的特点 浏览:586
dedev57漏洞工具下载 浏览:286
win10用户加密码 浏览:111
5s拆屏幕教程视频 浏览:511
微信支付宝语音笑话 浏览:992
word设置修改权限 浏览:171
武林外传浑天宝鉴升级 浏览:39
javamailmaven 浏览:115
一号车位app 浏览:771
用户ssh免密码登陆 浏览:396
向下滑动关闭后台程序 浏览:905