python 霍夫曼解码

Huffman Tree 进行解码 示例图   

c语言：c语言 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）_霍夫曼的贪婪c语言-CSDN博客

c++：c++ 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）_霍夫曼的贪婪算法设计核心代码-CSDN博客

c#：C# 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-CSDN博客

c++ STL：c++ STL 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-CSDN博客

java：java 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-CSDN博客

python：python 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-CSDN博客

javascript：JavaScript 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-CSDN博客

我们在之前的文章中 讨论了霍夫曼编码。在这篇文章中，我们将讨论解码。

例子：

输入数据： AAAAAABCCCCCCDDEEEEE
频率： A：6，B：1，C：6，D：2，E：5

编码数据： 00000000000011001010101010111111110101010

哈夫曼树： “#”是用于内部节点的特殊字符，因为
                         内部节点不需要字符字段。 

                    #(20)
                  / \
          #(12) #(8)
         / \ / \
     A(6) C(6) E(5) #(3)
                                 / \
                             B(1) D(2)  

‘A’ 的代码是 ‘00’，‘C’ 的代码是 ‘01’，..

解码数据： AAAAAAABCCCCCCDDEEEEE

输入数据： GeeksforGeeks

字符 频率为
e 10, f 1100, g 011, k 00, o 010, r 1101, s 111

编码的哈夫曼数据： 01110100011111000101101011101000111
解码的哈夫曼数据： geeksforgeeks

请按照以下步骤解决问题：

        注意：要解码编码数据，我们需要霍夫曼树。我们遍历二进制编码数据。要找到与当前位对应的字符，我们使用以下简单步骤：

        1、我们从根开始，依次进行，直到找到叶子。
        2、如果当前位为 0，我们就移动到树的左节点。
        3、如果该位为 1，我们移动到树的右节点。
        4、如果在遍历过程中遇到叶节点，我们会打印该特定叶节点的字符，然后再次从步骤 1 开始继续迭代编码数据。

        下面的代码将一个字符串作为输入，对其进行编码，并将其保存在变量编码字符串中。然后对其进行解码并打印原始字符串。 

下面是上述方法的实现：

import heapq
from collections import defaultdict
 
# to map each character its huffman value
codes = {}
 
# To store the frequency of character of the input data
freq = defaultdict(int)
 
# A Huffman tree node
class MinHeapNode:
    def __init__(self, data, freq):
        self.left = None
        self.right = None
        self.data = data
        self.freq = freq
 
    def __lt__(self, other):
        return self.freq < other.freq
 
# utility function to print characters along with
# there huffman value
def printCodes(root, str):
    if root is None:
        return
    if root.data != '$':
        print(root.data, ":", str)
    printCodes(root.left, str + "0")
    printCodes(root.right, str + "1")
 
# utility function to store characters along with
# there huffman value in a hash table
def storeCodes(root, str):
    if root is None:
        return
    if root.data != '$':
        codes[root.data] = str
    storeCodes(root.left, str + "0")
    storeCodes(root.right, str + "1")
 
# function to build the Huffman tree and store it
# in minHeap
def HuffmanCodes(size):
    global minHeap
    for key in freq:
        minHeap.append(MinHeapNode(key, freq[key]))
    heapq.heapify(minHeap)
    while len(minHeap) != 1:
        left = heapq.heappop(minHeap)
        right = heapq.heappop(minHeap)
        top = MinHeapNode('$', left.freq + right.freq)
        top.left = left
        top.right = right
        heapq.heappush(minHeap, top)
    storeCodes(minHeap[0], "")
 
# utility function to store map each character with its
# frequency in input string
def calcFreq(str, n):
    for i in range(n):
        freq[str[i]] += 1
 
# function iterates through the encoded string s
# if s[i]=='1' then move to node->right
# if s[i]=='0' then move to node->left
# if leaf node append the node->data to our output string
def decode_file(root, s):
    ans = ""
    curr = root
    n = len(s)
    for i in range(n):
        if s[i] == '0':
            curr = curr.left
        else:
            curr = curr.right
 
        # reached leaf node
        if curr.left is None and curr.right is None:
            ans += curr.data
            curr = root
    return ans + '\0'
 
# Driver code
if __name__ == "__main__":
    minHeap = []
    str = "geeksforgeeks"
    encodedString, decodedString = "", ""
    calcFreq(str, len(str))
    HuffmanCodes(len(str))
    print("Character With there Frequencies:")
    for key in sorted(codes):
        print(key, codes[key])
 
    for i in str:
        encodedString += codes[i]
 
    print("\nEncoded Huffman data:")
    print(encodedString)
 
    # Function call
    decodedString = decode_file(minHeap[0], encodedString)
    print("\nDecoded Huffman Data:")
    print(decodedString)

输出：
具有以下频率的字符：

e 10
f 1100
g 011
k 00
o 010
r 1101
s 111

编码的哈夫曼数据：
01110100011111000101101011101000111

解码的哈夫曼数据：
geeksforgeeks

时间复杂度：

        霍夫曼编码算法的时间复杂度为O(n log n)，其中n为输入字符串的字符个数。辅助空间复杂度也是O(n)，其中n为输入字符串的字符个数。

        在给定的 python 实现中，时间复杂度主要由使用优先级队列创建 Huffman 树决定，这需要 O(n log n) 时间。空间复杂度主要由用于存储字符频率和代码的映射决定，这需要 O(n) 空间。用于打印代码和存储代码的递归函数也增加了空间复杂度。

比较输入文件大小和输出文件大小： 
        比较输入文件大小和霍夫曼编码的输出文件。我们可以用一种简单的方法计算输出数据的大小。假设我们的输入是一个字符串“geeksforgeeks”，存储在文件 input.txt 中。 

输入文件大小：

输入： “geeksforgeeks”
字符总数即输入长度：13
大小： 13 个字符出现次数 * 8 位 = 104 位或 13 个字节。

输出文件大小：

输入： “geeksforgeeks”

——————————————————
字符 | 频率 | 二进制哈夫曼值 |
——————————————————

   e | 4 | 10 |
   f | 1 | 1100 |   
   g | 2 | 011 |
   k | 2 | 00 |
   o | 1 | 010 |
   r | 1 | 1101 |
   s | 2 | 111 | 

—————————————————

因此要计算输出大小：

e：出现 4 次 * 2 位 = 8 位
f：出现 1 次 * 4 位 = 4 位
g：出现 2 次 * 3 位 = 6 位
k：出现 2 次 * 2 位 = 4 位
o：出现 1 次 * 3 位 = 3 位
r：出现 1 次 * 4 位 = 4 位
s：出现 2 次 * 3 位 = 6 位

总和： 35 位，约 5 字节

        由此可见，编码后的数据量是比较大的，上面的方法也可以帮我们确定N的值，也就是编码后数据的长度。