赫夫曼编码_数据压缩_python
一、什么是赫夫曼编码
基本介绍
- 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种加粗样式程序算法
- 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
- 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间
- 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码
要想了解赫夫曼编码，先要了解什么是赫夫曼树。
二、赫夫曼树
基本介绍
- 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman
Tree), 还有的书翻译为霍夫曼树。 - 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
重要概念
- . 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1
- 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积
- 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted path length)
,权值越大的结点离根结点越近的二叉树才是最优二叉树。 - WPL最小的就是赫夫曼树
赫夫曼树创建思路
给你一个数列 {13, 7, 8, 3, 29, 6, 1}，要求转成一颗赫夫曼树.
{13, 7, 8, 3, 29, 6, 1}
构成赫夫曼树的步骤：
- 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树
- 取出根节点权值最小的两颗二叉树
- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
- 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4
的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树
三、构造赫夫曼树python实现
(1)先定义好赫夫曼树的最小单元node，node具有三个属性：值、左节点、右节点；其次为了能够进行排序和输出，node对象中应该还具有两个函数compareTo(node) 和 preOrder()。前者用来比较自身节点的值和其他节点的值，后者可以按照根左右的顺序即前序遍历来输出节点。
class Node(object):
def __init__(self,value):
self.value=value
self.left=None
self.right=None
def compareTo(self,node):
#如果自身大于为正，否则为负
return self.value-node.value
def preOrder(self):
print(self.value)
if self.left!=None:
self.left.preOrder()
if self.right!=None:
self.right.preOrder()
（2）根据前面所讲的赫夫曼树的构造方法，我们还需要一个能够根据节点的值对节点进行排序的算法，这里我们使用最简单冒泡算法来进行排序。
def BubleSort2(arr):
temp = 0
flag = False
#总共要进行数组长度减1的大循环
for i in range(len(arr)-1):
flag = False
#每次内循环都会冒出一个最小或者最大值，故下次循环比较次数-1
for j in range(len(arr)-1-i):
if arr[j].compareTo(arr[j+1])>0:
flag = True
t=arr[j]
arr[j]=arr[j+1]
arr[j+1]=t
#如果没有一次进入交换语句，说明后面的数字都已经有序
if flag == False:
break
（3）接下来只需要严格按照前面所说的步骤就可以构造一个赫夫曼树了。构造函数createHuffmanTree(arr)，其中arr是赫夫曼树节点中的值的集合。
- 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树
nodes = []
for i in range(len(arr)):
nodes.append(Node(arr[i]))
while len(nodes)>1:
#排序
BubleSort2(nodes)
'''
测试是否排序成功
for i in range(len(nodes)):
print('node=%d'%(nodes[i].value))
'''
- 取出根节点权值最小的两颗二叉树
#取出最小的两个构成二叉树
left = nodes[0]
right = nodes[1]
- 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
#构成新的二叉树
parent = Node(left.value+right.value)
parent.left=left
parent.right=right
- 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4
的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树
while len(nodes)>1:
'''
省略
'''
#在nodes里面删除使用过的元素
nodes.remove(left)
nodes.remove(right)
#加入parent
nodes.append(parent)
for i in range(len(nodes)):
print('node=%d'%(nodes[i].value))
构造赫夫曼树完整代码
class Node(object):
def __init__(self,value):
self.value=value
self.left=None
self.right=None
def compareTo(self,node):
#如果自身大于为正，否则为负
return self.value-node.value
def preOrder(self):
print(self.value)
if self.left!=None:
self.left.preOrder()
if self.right!=None:
self.right.preOrder()
arr = [13,7,8,3,29,6,1]
def BubleSort2(arr):
temp = 0
flag = False
#总共要进行数组长度减1的大循环
for i in range(len(arr)-1):
flag = False
#每次内循环都会冒出一个最小或者最大值，故下次循环比较次数-1
for j in range(len(arr)-1-i):
if arr[j].compareTo(arr[j+1])>0:
flag = True
t=arr[j]
arr[j]=arr[j+1]
arr[j+1]=t
#如果没有一次进入交换语句，说明后面的数字都已经有序
if flag == False:
break
def createHuffmanTree(arr):
nodes = []
for i in range(len(arr)):
nodes.append(Node(arr[i]))
while len(nodes)>1:
#排序
BubleSort2(nodes)
'''
for i in range(len(nodes)):
print('node=%d'%(nodes[i].value))
'''
#取出最小的两个构成二叉树
left = nodes[0]
right = nodes[1]
#构成新的二叉树
parent = Node(left.value+right.value)
parent.left=left
parent.right=right
#在nodes里面删除使用过的元素
nodes.remove(left)
nodes.remove(right)
#加入parent
nodes.append(parent)
for i in range(len(nodes)):
print('node=%d'%(nodes[i].value))
return nodes[0]
node = createHuffmanTree(arr)
node.preOrder()
四、根据赫夫曼树得到赫夫曼编码
假设原始数据为 content = “哈哈哈，我欲乘风归去，归去”。
把原始数据中的每个字符当作值构造一个赫夫曼树，得到的对应的赫夫曼编码为：
{‘风’: ‘111’, ‘。’: ‘110’, ‘哈’: ‘10’, ‘归’: ‘011’, ‘去’: ‘010’, ‘，’: ‘0011’, ‘我’: ‘0010’, ‘欲’: ‘0001’, ‘乘’: ‘0000’}
这个编码并不是唯一的，但是你能根据每个编码对应了一个确定的位置，既不会出现二义性。并且你会发现使用频率越高的元素它的编码越简短。
要实现这个目标很简单，你只需要在原先的node对象中添加一个getCodes(node,code)方法，它的作用是根据目前的赫夫曼编码得到下一层节点的赫夫曼编码。运用递归的思想，假设你想知道节点<哈>的赫夫曼编码，你可以说这个编码等于节点<哈>的根节点赫夫曼编码加上到节点<哈>的编码，向左编码为1，向右编码为0。
def getCodes(self,node,code):
self.pathStr=self.pathStr+code
#print('到达'+str(node.data)+':'+str(node.weight))
if node!=None:
if node.data==None:#不是叶子节点
#左递归
self.getCodes(node.left,"1")
#右递归
self.getCodes(node.right,"0")
else:#叶子结点
self.dic[str(node.data)]=self.pathStr
self.pathStr=self.pathStr[0:-1]
return self.dic
五、数据压缩
根据赫夫曼编码得到对应的二进制编码
这个步骤如果不考虑细节的话，其实两行代码就完成了。不就是根据原先得到值和赫夫曼编码的字典连接起来就好了吗？
#先将数据转换成对应的字符串
StrHuffman = ""
for i in range(len(content)):
StrHuffman += dic[content[i]]
print('二进制的赫夫曼编码：')
print(StrHuffman)
但是实际的二进制数据都是8的倍数，也就是说如果得到的二进制编码不是刚好为8的倍数时，需要在数据尾部补0。然后根据二进制数转换为对应的十进制数，达到数据压缩的效果。所以最终的代码如下：
#根据得到的赫夫曼编码对数据进行压缩
def Zip(dic,byte):
#先将数据转换成对应的字符串
StrHuffman = ""
for i in range(len(content)):
StrHuffman += dic[content[i]]
print('二进制的赫夫曼编码：')
print(StrHuffman)
lenth = int((len(StrHuffman)+7)/8)
byte = [0 for i in range(lenth)]#存储字节
index=0#记录第几个字节
for i in range(0,len(StrHuffman),8):
#print(i)
if i+8>len(StrHuffman):
strByte = StrHuffman[i:]
else:
strByte = StrHuffman[i:i+8]
byte[index]=int(strByte,2)
#print('-------'+str(strByte))
index+=1
return byte
六、数据解压
想要把压缩后的十进制数据转换成原始数据，需要先得到对应的二进制编码。
#先得到Bytes对应的二进制编码
bitStr = ''
result = ''
for i in range(len(Bytes)):
byte = Bytes[i]
flag = not(i==len(Bytes)-1)
bitStr += zipToBit(flag,byte)
print(bitStr)
之后要把赫夫曼编码字典进行反转，也就是键值对的位置互换位置。在python中可以使用dict(zip(dic.values(),dic.keys()))这个方法来进行反转。
dic = dict( zip(dic.values(),dic.keys()))
接下来的工作就简单，根据二进制编码查找对应的字典值即可。解码完整代码如下：
#将二进制编码转换成原始数据
def bitToData(Bytes,dic):
#先得到Bytes对应的二进制编码
bitStr = ''
result = ''
for i in range(len(Bytes)):
byte = Bytes[i]
flag = not(i==len(Bytes)-1)
bitStr += zipToBit(flag,byte)
print(bitStr)
#print(bitStr[:3])
#print(bitStr[3:])
#将二进制编码按照赫夫曼编码进行阶码
#要反向查询，需要将字典反转
dic = dict( zip(dic.values(),dic.keys()))
#print(dic)
i=1
while len(bitStr)>0:
#print(bitStr[:i])
if bitStr[:i] in dic.keys():
result+=dic[bitStr[:i]]
bitStr=bitStr[i:]
length=len(bitStr)
i=0
i+=1
print(result)
return result
七、运行结果
