哈夫曼编码图片压缩

⑴ 为什么说哈夫曼编码是压缩率最高的编码

假设用于通信的电文由字符集{a,b,c,d,e,f,g,h}中的字母构成，这8个字母在电文中出现的概率分别为{0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.10}。

哈夫曼编码 根据上面可得编码表： a:1001 b:01 c:10111 d:1010 e:11 f:10110 g:00 h:1000

用三位二进行数进行的等长编码平均长度为3，而根据哈夫曼树编码的平均码长为：4*0.07+2*0.19+5*0.02+4*0.06+2*0.32+5*0.03+2*0.21+4*0.10=2.61 2.61/3=0.87=87%其平均码长是等长码的87%，所以平均压缩率为13%。

因为定长编码已经用相同的位数这个条件保证了任一个字符的编码都不会成为其它编码的前缀,所以这种情况只会出现在变长编码当中，要想避免这种情况，

就必须用一个条件来制约定长编码，这个条件就是要想成为压缩编码，变长编码就必须是前缀编码，所谓的前缀编码就是任何一个字符的编码都不能是另一个字符编码的前缀。

(1)哈夫曼编码图片压缩扩展阅读：

实际应用中，除采用定时清洗以消除误差扩散和采用缓冲存储以解决速率匹配以外，主要问题是解决小符号集合的统计匹配，

例如黑（1）、白（0）传真信源的统计匹配，采用0和1不同长度游程组成扩大的符号集合信源。游程，指相同码元的长度（如二进码中连续的一串0或一串1的长度或个数）。按照CCITT标准，需要统计2×1728种游程（长度），

这样，实现时的存储量太大。事实上长游程的概率很小，故CCITT还规定：若l表示游程长度，则l=64q+r。其中q称主码，r为基码。编码时，不小于64的游程长度由主码和基码组成。而当l为64的整数倍时，只用主码的代码，已不存在基码的代码。

⑵ 利用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文件），则不能使用这种机制来获得很高的压缩率，因为它们不包含重复多次的模式。
如果文件有大量重复模式，那么压缩率通常会随着文件大小的增加而增加。从我们的例子中就可以看出这一点——如果我们摘录的肯尼迪讲话再长一些，您会发现又多次出现了我们字典中的模式，因此能够通过每个字典条目节省更多的文件空间。此外，对于更大的文件，还可能出现具有更大普遍性的模式，从而能够创建出效率更高的字典。
此外，文件压缩效率还取决于压缩程序使用的具体算法。有些程序能够在某些类型的文件中更好地寻找到模式，因此能更有效地压缩这些类型的文件。其他一些压缩程序在字典中又使用了字典，这使它们在压缩大文件时表现很好，但是在压缩较小的文件时效率不高。尽管这一类的所有压缩程序都基于同一个基本理念，但是它们的执行方式却各不相同。程序开发人员始终在尝试建立更好的压缩机制。
有损压缩和无损压缩
我们在上文中讨论的压缩类型称为无损压缩，因为您重新创建的文件与原始文件完全相同。所有无损压缩都基于这样一种理念：将文件变为“较小”的形式以利于传输或存储，并在另一方收到它后复原以便重新使用它。
有损压缩则与此大不相同。这些程序直接去除“不必要”的信息，对文件进行剪裁以使它变得更小。这种类型的压缩大量应用于减小位图图像的文件大小，因为位图图像的体积通常非常庞大。为了了解有损压缩的工作原理，让我们看看你的计算机如何对一张扫描的照片进行压缩。
对于此类文件，无损压缩程序的压缩率通常不高。尽管图片的大部分看起来都是相同的——例如，整个天空都是蓝色的——但是大部分像素之间都存在微小的差异。为了使图片变得更小同时不降低其分辨率，您必须更改某些像素的颜色值。如果图片中包含大量的蓝色天空，程序会挑选一种能够用于所有像素的蓝色。然后，程序重写该文件，所有天空像素的值都使用此信息。如果压缩方案选择得当，您不会注意到任何变化，但是文件大小会显着减小。
当然，对于有损压缩，在文件压缩后您无法将其复原成原始文件的样子。您必须接受压缩程序对原始文件的重新解释。因此，如果需要完全重现原来的内容（例如软件应用程序、数据库和总统就职演说），则不应该使用这种压缩形式。

⑶ 利用哈夫曼编码进行压缩压缩率一般达到多少

哈夫曼编码进行压缩的压缩率是根据平均码长来计算的，压缩率比较低。

例如：用三位二进行数进行的等长编码平均长度为3，而根据哈夫曼树编码的平均码长为：

4*0.07+2*0.19+5*0.02+4*0.06+2*0.32+5*0.03+2*0.21+4*0.10=2.61

2.61/3=0.87=87%

其平均码长是等长码的87%，所以平均压缩率为13%。

哈夫曼编码，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。

Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。

压缩率，描述压缩文件的效果名，是文件压缩后的大小与压缩前的大小之比，例如：把100m的文件压缩后是90m，压缩率为90/100*100%=90%，压缩率一般是越小越好，但是压得越小，解压时间越长。

(3)哈夫曼编码图片压缩扩展阅读

哈夫曼编码的具体方法：先按出现的概率大小排队，把两个最小的概率相加，作为新的概率 和剩余的概率重新排队，再把最小的两个概率相加，再重新排队，直到最后变成1。

每次相 加时都将“0”和“1”赋与相加的两个概率，读出时由该符号开始一直走到最后的“1”， 将路线上所遇到的“0”和“1”按最低位到最高位的顺序排好，就是该符号的哈夫曼编码。

⑷ 哈夫曼编码（理论）

哈夫曼编码是一种无损压缩文件一种方法，他的思路很简单，却又十分经典，他利用的是无重复前缀这种思想，就是每个字符的前缀是唯一的，若a的编码是001，那么就不会存在另一个以001开头的编码了，因为，哈夫曼编码是以二叉树为基础实现的，而二叉树到每一个叶子节点的路径是唯一的，那么也就是说每一个字符的编码也是唯一的。

哈夫曼编码是一种变长编码，比起定长编码的ascii码来说，哈夫曼编码能节省很多的空间，因为每一个字符出现的频率不是一致的，例如在英语中，‘e’出现的次数是最高的，那么如果我把‘e’的编码定义的短一点，那么是不是比起定长编码来说，空间就减少了？

基于这种思路，哈夫曼编码的具体实现过程如下：
（1）首先统计文本中各字符出现的频率（权重）。
（2）使用这些频率（权重），构建出哈夫曼树。
（3）规定从根节点开始，向叶子节点行走，经过左子树，编码为0，右子树，编码为1，这样就能得到每一个叶子节点字符的编码值了。

⑸ 哈夫曼编码做压缩软件的问题c++

因为32个0、1是4个字节。（因为8个0、1是一个字节）
但是它这个东西算出来的是一个0、1占一个字节的那种
所以要变成32个0、1占4字节的那种

⑹ 如何用哈夫曼编码对图像进行压缩

% 演示图象的哈夫曼编解码过程
% chenyong 2009.04.20

clear all;
close all;
clc;
Dimens = 256; % 矩阵维数，假设矩阵为方阵即256*256
src_size = Dimens^2; % 矩阵元素的个数
gray_level = 9; % 灰度级

src = randn(Dimens); %产生模拟图像矩阵，满足正态分布，零均值，方差为1
%src = randint(Dimens,Dimens,gray_level); % 产生随机图像矩阵，灰度值为0~63，满足均匀分布
src_one = reshape(src,1,src_size);
src_max = max(src_one);
src_min = min(src_one);
quan = linspace(src_min,src_max,gray_level); % 产生均匀量化区间
src_d = []; % 数字矩阵
for row = 1:Dimens % 逐点量化
for vol = 1:Dimens
diff = abs(src(row,vol)-quan);
[min_diff,min_index] = min(diff);
quan_gray = min_index -1;
src_d(row,vol) = quan_gray;
end
end

%将数字图像矩阵还原成模拟矩阵
src_a = [];
quan_space = quan(2)-quan(1);
for row = 1:Dimens
for vol = 1:Dimens
src_a(row,vol) = src_d(row,vol) * quan_space + src_min;
end
end

% prob数组保存图像中各灰度出现的概率
prob = [];
for src_value=0:(gray_level-1)
index = find(src_d==src_value);
i = src_value + 1;
prob(i) = length(index)/src_size;
end

% 画出直方图
% stem(0:gray_level-1,prob);
% xlabel('灰度值');
% ylabel('概率');
% title('灰度直方图');

% huffman编码
p = prob;
n=length(p);
q=p;
m=zeros(n-1,n);
for i=1:n-1
[q,l]=sort(q);
m(i,:)=[l(1:n-i+1),zeros(1,i-1)];
q=[q(1)+q(2),q(3:n),1];
end
bre=zeros(n-1,n);
bre(n-1,1)=0+j; %虚部表示当前的二进制数的位数，以下类似
bre(n-1,2)=1+j;
for time=1:n-2
loc_1 = find(real(m(n-time,:))==1);
prebit = bre(n-time,loc_1);
bre(n-time-1,1) = (real(prebit)*2 + 0) + j*(imag(prebit)+1);
bre(n-time-1,2) = (real(prebit)*2 + 1) + j*(imag(prebit)+1);

loc_not1 = find(real(m(n-time,:))>1);
bre(n-time-1,3:3+time-1) = bre(n-time,loc_not1);
end
[m1,index] = sort(m(1,:));
code = bre(1,index);
code_data = real(code);
code_bits = imag(code);
disp(['gray level',' ', 'huffman code']);
for i = 1:length(code)
disp([num2str(i-1),' ' ,num2str(dec2bin(code_data(i)))]);
disp([num2str(i-1),' ' ,num2str(dec2bin(code_data(i),code_bits(i)))]);
end
code_binary = dec2bin(code_data);

%逐点编码
out = [];
for row = 1:Dimens
for vol = 1:Dimens
now_gray = src_d(row,vol);
now_code = code_binary(now_gray+1,:);
now_bits = code_bits(now_gray+1);
now_code = now_code(end-now_bits+1:end);
out = [out, now_code];
end
end

%计算压缩比
real_bitnum = length(out);
bitnum_no_huffman = src_size*nextpow2(gray_level);
comp_ratio =bitnum_no_huffman/real_bitnum;
Lavg = real_bitnum/src_size;
Hshannon = (-1)*prob*(log2(prob))';
disp(['Lavg = ',num2str(Lavg)]);
disp(['normal bit num = ',num2str(nextpow2(gray_level))]);
disp(['comp_ratio = ',num2str(comp_ratio)]);
disp(['Hshannon = ',num2str(Hshannon)]);

⑺ 数字图像压缩技术

⑻ 哈夫曼编码的压缩实现

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