Huffman编码及其实现[Python]

Huffman编码是信源编码的一种，与香农压缩编码一样，都是为了压缩码率，即：用较短的码长去表征信源内的信息。

其思路大致可以描述为：给信源内，出现次数越多的事件，编以较短的码字，次数越少，编以较长的码字。大体思路与香农编码类似，但是不同的是香农是自顶向下去构建完全二叉树的【即每次都把事件组依概率进行近似等分，以此来构建树】；Huffman是自下向上，从最优子树开始构建【即每次都找最小概率的两个事件作为子节点，合成父节点概率后再将这个概率放回事件组中继续找最小概率的事件】

Huffman编码的实现主要可以分为两步：构建Huffman树+遍历节点编码【我的思路是分成两步做……】

其中Huffman树构建，有一步比较重要的是重置<号，也就是def __lt__(self,other)这个方法，他的作用是一旦出现了对于类实例的<比较，就调用这个方法，比如我在这里设计的是比较两个实例的值属性大小。此部分理解出自于stackoverflow：

python - Unable to understand __lt__ method - Stack Overflow

总体上来说 Huffman树构建用到了完全二叉树以及优先队列，编码我用的是类似于PCM编码里的层编码+层内编码的思路，逐层遍历树的结点，去编码。

from heapq import heapify,heappop,heappush
import heapq

class TreeNodes():
    def __init__(self,val,lchild=None,rchild=None): # 构造函数参数设置为None，就可以在构造时先不用提供，等到先构造完毕后再用语句提供
        self.val = val
        self.lchild = lchild
        self.rchild = rchild
    
    def __lt__(self,other):
        return self.val < other.val    # change the '<' function if used on those objects:just compare the val between the two object


def Huffman_Tree(arr):
    heapq.heapify(arr)
    arrNode = [TreeNodes(val) for val in arr]
    
    while len(arrNode) > 1:
        min1 = heapq.heappop(arrNode)
        min2 = heapq.heappop(arrNode)
        # print(min1.val,min2.val)

        newNode = TreeNodes(val=min1.val+min2.val,lchild = min1,rchild=min2)
        heapq.heappush(arrNode,newNode)

    return arrNode

    
arr = [0.07,0.13,0.22,0.01,0.57]
arrNode = Huffman_Tree(arr)
root = arrNode[0]


def recurseTreeNode(Node):
    if Node == None:
        return
    
    print(Node.val)
    recurseTreeNode(Node.lchild)
    recurseTreeNode(Node.rchild)

# recurseTreeNode(root)


def encoder(root):
    if root is None:
        return
    
    myqueue = []
    myqueue.append(root)

    turn = 1
    realTurn = 0
    dict = {}
    while len(myqueue) !=0 :
        node = myqueue.pop(0)
        flag = 0 if turn % 2 == 0 else 1       # flag每轮交替 用来编写[层内编码]

        realTurn += 1 if turn % 2 == 0 else 0  # 用来编[层编码]的位数
        
        layerCode = str(flag)*realTurn

        if node.lchild is not None:
            layerInCode = '0'
            huffmanCode = layerCode + layerInCode
            dict[node.lchild.val] = huffmanCode 
            myqueue.append(node.lchild)
            # 把val作为键 把encode作为值 后面再提取子集
        if node.rchild is not None:
            myqueue.append(node.rchild)
            layerInCode = '1'
            huffmanCode = layerCode + layerInCode
            dict[node.rchild.val] = huffmanCode

            # 把val作为键 把encode作为值 后面再提取子集
        
        turn += 1
        
    return dict

dict = encoder(root)

arrDict = {}
for key,value in dict.items():
    if key in arr:
        arrDict[key] = value

print(arrDict)

Result：

Reference：

Building Collision Simulations: An Introduction to Computer Graphics - YouTube

香农范诺双飞翼，Huffman编码一点通_哔哩哔哩_bilibili

Huffman编码及其实现[Python]

猜你喜欢