哈夫曼树、哈夫曼编码/解码

哈夫曼树

哈夫曼树的基本介绍

哈夫曼树构建步骤图解

创建哈夫曼树代码实现

""" 创建哈夫曼树 """
class EleNode:
    """ 节点类 """
    def __init__(self, value: int):
        self.value = value
        self.left = None  # 指向左子节点
        self.right = None  # 指向右子节点

    def __str__(self):
        return f"Node [value={self.value}]"

    def pre_order(self):
        """前序遍历二叉树"""
        if self is None:
            return
        # 先输出父节点
        print(self, end=' => ')
        # 左子树不为空则递归左子树
        if self.left is not None:
            self.left.pre_order()
        # 右子树不为空则递归右子树
        if self.right is not None:
            self.right.pre_order()


class HuffmanTree:
    arr: list = None

    def __init__(self, arr):
        self.arr = arr

    def create_huffman_tree(self) -> EleNode:
        # 对 arr 列表进行升序排序
        self.arr.sort()
        # 遍历数组，将每个数组元素构建成一个 Node 节点
        # 将 Node 节点加入到一个新列表中
        node_list = []
        for i in self.arr:
            node_list.append(EleNode(i))

        # 循环进行以下步骤，直到列表中只剩下一棵二叉树，此时该二叉树就是哈夫曼树
        while len(node_list) > 1:
            # 取出权值序列中最小的两课二叉树（即列表中的前两个元素）构建一棵新的二叉树
            left = node_list.pop(0)
            right = node_list.pop(0)
            # 新二叉树的根节点的权值=两个节点权值之和
            parent = EleNode(left.value + right.value)
            # 让新二叉树的左右节点分别指向两个最小的节点
            parent.left = left
            parent.right = right
            # 将新二叉树根据根节点的大小插入到序列中的指定位置
            i = 0
            n = len(node_list)
            while i < n:
                if node_list[i].value >= parent.value:
                    node_list.insert(i, parent)  # 找到了根节点存放的位置
                    break
                i += 1
            else:
                # 循环结束表示新的二叉树的权值最大，在node_list列表中没有比它大的
                # 所以添加到列表最后
                node_list.append(parent)

        # 此时列表中只有一棵二叉树，即所求的哈夫曼树
        # 返回哈夫曼树的根结点
        return node_list[0]


huffman = HuffmanTree([13, 7, 8, 3, 29, 6, 1])
node = huffman.create_huffman_tree()
node.pre_order()

哈夫曼编码

基本介绍

哈夫曼编码原理剖析

哈夫曼编码的实例

思路分析

代码实现

""" 哈夫曼编码 """
class CodeNode:
    def __init__(self, data: int, weight: int):
        self.data = data  # 存放字符对应的ASCII码值
        self.weight = weight  # 存放字符在字符串中出现的次数
        self.left = None
        self.right = None

    def __str__(self):
        return f"Node[data={chr(self.data) if self.data else None}, weight={self.weight}]"

    def pre_order(self):
        """二叉树的前序遍历"""
        print(self)
        if self.left:
            self.left.pre_order()
        if self.right:
            self.right.pre_order()


class HuffmanCode:
    # 哈夫曼编码表
    # 存储每个字符对应的编码
    # key为对应的字符，val为字符对应的编码
    huffman_code_tab = {}
    # 记录哈夫曼二进制编码字符串最后一个段的长度
    # 即会将哈夫曼二进制字符串按八位进行分割，分割到最后一个时长度可不为8
    # 所以用一个变量存储最后一段二进制字符串的长度，在解码的时候会用到
    last_char_len = 0

    def create_huffman_tree(self, s: str) -> CodeNode:
        """
        构建哈夫曼编码二叉树
        :param s: 要编码的字符串
        :return:
        """
        # 遍历字符串，统计每一个字符出现的次数，并将结果放入字典
        kw = {}
        for ch in s:
            ascii_code = ord(ch)
            if kw.get(ascii_code):  # 如果该字符出现过，则直接将其次数加1
                kw[ascii_code] += 1
            else:  # 如果没出现过，则出现次数为1
                kw[ascii_code] = 1

        # 按照字符出现的次数对字典进行排序
        kw = sorted(kw.items(), key=lambda kv: (kv[1], kv[0]))
        # 遍历字典，将每个元素构建成一个 Node 节点
        # 将 Node 节点加入到一个新列表中
        node_list = []
        for k, v in kw:
            # print(chr(k),'=', v, end=', ')
            node_list.append(CodeNode(k, v))

        # 循环进行以下步骤，直到列表中只剩下一棵二叉树，此时该二叉树就是哈夫曼树
        while len(node_list) > 1:
            # 取出权值序列中最小的两课二叉树（即列表中的前两个元素）构建一棵新的二叉树
            left = node_list.pop(0)
            right = node_list.pop(0)
            # 新二叉树的根节点的权值=两个节点权值之和
            parent = CodeNode(None, left.weight + right.weight)
            # 让新二叉树的左右节点分别指向两个最小的节点
            parent.left = left
            parent.right = right
            # 将新二叉树根据根节点的大小插入到序列中的指定位置
            n = len(node_list)
            i = 0
            while i < n:
                if node_list[i].weight >= parent.weight:
                    node_list.insert(i, parent)  # 找到了根节点存放的位置
                    break
                i += 1
            else:
                # 循环结束表示新的二叉树的权值最大，在node_list列表中没有比它大的
                # 所以添加到列表最后
                node_list.append(parent)

        # 此时列表中只有一棵二叉树，即所求的哈夫曼树
        # 返回哈夫曼树的根结点
        return node_list[0]

    def get_huffman_code_tab(self, ele_node: CodeNode, code: str, code_str: str):
        """
        遍历所创建的哈夫曼树，得到所有叶子节点（叶子结点即要得到的字符）的编码
        这里规定左节点为0，右节点为1
        :param ele_node: 传入的要遍历的树的根节点，初始为根节点
        :param code: 表示所选择的路径是左节点还是右节点
        :param code_str: 每个字符对应的编码
        :return:
        """
        code_str += code  # 拼接编码
        if ele_node.data is None:
            # 表示是非叶子节点，因为在创建哈夫曼树时设置了为叶子结点的data为空
            # code_str += code
            if ele_node.left:
                self.get_huffman_code_tab(ele_node.left, '0', code_str)
            if ele_node.right:
                self.get_huffman_code_tab(ele_node.right, '1', code_str)
        else:  # 是叶子节点
            self.huffman_code_tab[chr(ele_node.data)] = code_str

    def huffman_zip(self, s: str) -> list:
        """
        利用哈夫曼编码表把字符串中的每一个字符转换成对应的编码
        即将一个字符串根据哈夫曼编码进行压缩，得到一个压缩后的结果
        :param s: 要转换的字符串
        :return: 返回编码后的列表
        """
        res = ''
        # 遍历字符串，将每一个字符转换成对应的编码，并将所有编码拼接起来
        # "i like like like java do you like a java" => 以下形式
        # 1100111111101110001011111110111000101111111011100010100001011000101011
        # 001100001011001000011001110111111101110001011010100001011000101
        for i in s:
            res += self.huffman_code_tab[i]
        # 将得到的编码字符串按八位进行分割，将每八位转换成一个int，并将int存放到列表中
        code_list = []
        i = 0
        n = len(res)
        while i < n:
            num = int(res[i:i + 8], 2)  # 将二进制字符串转换为整数
            code_list.append(num)
            i += 8
            if i < n <= i + 8:  # 已经分割到了最后一部分，记录该部分的长度
                self.last_char_len = n - i

        return code_list

    def huffman_decode(self, code_list) -> str:
        """
        将哈夫曼编码进行解压，得到一个可阅读的字符串
        :param code_list: 要解压的哈夫曼编码列表
        :return: 解码后的字符串
        """
        # 将哈夫曼编码列表转换成对应的二进制字符串
        # [415, 476, 95, 476, 95, 476, 80, 177, 345, 389, 400, 206, 254, 226, 212, 44, 5] =>
        # 1100111111101110001011111110111000101111111011100010100001011000101011
        # 001100001011001000011001110111111101110001011010100001011000101
        code_str = ''  # 存储对应的二进制字符串
        count = 0
        n = len(code_list)
        for i in code_list:
            t = "{:08b}".format(i)  # 将整数转换为二进制字符串
            code_str += t
            count += 1
            if count == n - 1:
                break
        code_str += "{:0{k}b}".format(code_list[count], k=self.last_char_len)

        # 将哈夫曼编码表的键值互换
        # 比如原来的是'a': '001' => 变成 '001': 'a'
        code_tab = {}
        for k, v in self.huffman_code_tab.items():
            code_tab[v] = k

        # 遍历二进制字符串
        j = 0
        i = 1
        n = len(code_str)
        res_code = ''  # 解码后的字符串
        while i <= n:
            t = code_str[j:i]
            ch = code_tab.get(t)
            if ch:
                res_code += ch
                j = i
            i += 1
        return res_code


s = "i like like like java do you like a java"
# s = "I love python hahha nihao"
huffman = HuffmanCode()
root_node = huffman.create_huffman_tree(s)
huffman.get_huffman_code_tab(root_node, '', '')
huffman_code_list = huffman.huffman_zip(s)
decode_str = huffman.huffman_decode(huffman_code_list)
print(decode_str)

使用哈夫曼编码压缩文件的注意事项（代码胜省略）