SICP_Python版本:Hufuman编码

采用递归定义来构造hufuman树,且进行编码解码。

def make_leaf(symbol,weight):
    return ('leaf',symbol,weight)
def is_leaf(obj):
    return obj[0]=='leaf'
def weight_ofleaf(x):return x[2]
def symbol_ofleaf(x):return x[1]
def make_tree(left,right):
    return ('node',left,right,weight(left)+weight(right),symbols(left)+symbols(right))
def lefttree(t):return t[1]
def righttree(t):return t[2]
def symbols(t):return symbol_ofleaf(t) if is_leaf(t) else t[4]
def weight(t): return weight_ofleaf(t) if is_leaf(t) else t[3]
def dec(bits,tree):
    def decode_one():
        nonlocal bits,tree,i
        node = tree
        while not is_leaf(node):
            if bits[i]=='0':node = lefttree(node)
            elif bits[i]=='1':node = righttree(node)
            else:assert(bits[i]=='0' or bits[i]=='1')
            i+=1
        return symbol_ofleaf(node)
    i,n = 0,len(bits)
    res = []
    while i<n:res.append(decode_one())
    return res
def create_set(l):
    u = sorted(l,key = lambda x:x[1])
    return set([make_leaf(e[0],e[1]) for e in u])
sample_tree = make_tree(make_leaf('A',4),make_tree(make_leaf('B',2),make_tree(make_leaf('D',1),make_leaf('C',1))))
#print(dec('0110010101110',sample_tree))
def encode(message,tree):
    def encode_symbol(symbol,tree):
        if is_leaf(tree):return ''
        if symbol in symbols(lefttree(tree)):return '0'+encode_symbol(symbol,lefttree(tree))
        else:return '1'+encode_symbol(symbol,righttree(tree))

    if len(message)==0:return ''
    return encode_symbol(message[0],tree)+encode(message[1:],tree)

$2.71$很容易判断出来每次最小两个子树的权重和还是当前最小的,不改变原本的顺序。所以最频繁的用1个二进制,最不频繁的用n-1个二进制。

$2.72$这里需要稍微分情况看待问题:

$(a):$如果符号表利用了hash表,那么最频繁的编码复杂度始终是O(1)，而最不频繁的是O(n)

$(b):$如果直接查找符号,那么最不频繁的应该是O(N),当然你可以构造树时总将权重较大的放在同一个位置(left or right)，这样也就是O(1).如果随即放两个子树的位置,那么应该是O(n).

对于最频繁的来说$T(N) = O(N)+O(N-1)+....O(1) = O(N^2)$