哈夫曼编码

【理论知识可以参考】

数据结构：哈夫曼树和哈夫曼编码

 

# 哈夫曼编解码过程要依赖一棵最优二叉树，ta具有最小带权路径长度wpl，所以首先需要生成这个最优二叉树 

# 这棵最优二叉树也叫哈夫曼树

local HuffmanTreeNode = {}
HuffmanTreeNode.__index = HuffmanTreeNode

function HuffmanTreeNode.new(w, v)
    local obj = {}
    setmetatable(obj, HuffmanTreeNode)
    obj:ctor(w, v)
    return obj
end

function HuffmanTreeNode:ctor(w, v)
    self.weight = w
    self.value = v or w---元素值
    self.left = nil ---左子节点
    self.right = nil ---右子节点
    self.parent = nil ---父节点
end

function HuffmanTreeNode:SetLeft(l)
    self.left = l
    l.parent = self
end

function HuffmanTreeNode:SetRight(r)
    self.right = r
    r.parent = self
end

function HuffmanTreeNode:IsLeaf()
    return nil == self.left and nil == self.right
end

 

# 构建的过程就是不断的取2个权值最小的节点组成新节点，直到取完

# 如果遇到新组成的节点权值和已有节点相同的，优先用已有节点

local HuffmanTree = {}
HuffmanTree.__index = HuffmanTree

function HuffmanTree.new()
    local obj = {}
    setmetatable(obj, HuffmanTree)
    obj:ctor()
    return obj
end

function HuffmanTree:ctor()
    self.root = nil ---根节点
    self.codesQueryDict = nil ---编码查询表
end

function HuffmanTree:Build(nodeArr)
    local ct = #nodeArr

    local minHeap = {} --这边暂时用数组模拟最小堆
    for i=1,ct do
        minHeap[i] = nodeArr[i]
    end
    local sortFunc = function(a, b)
        if a.weight == b.weight then
            local aNoParent = (nil == a.parent)
            local bNoParent = (nil == b.parent)
            if aNoParent ~= bNoParent then
                return aNoParent
            end
        end
        return a.weight < b.weight --小的排前面
    end
    table.sort(minHeap, sortFunc)

    local parent = nil
    while #minHeap > 1 do
        local node1 = minHeap[1]
        local node2 = minHeap[2]
        table.remove(minHeap, 1)
        table.remove(minHeap, 1)

        parent = HuffmanTreeNode.new(node1.weight + node2.weight, nil)
        parent:SetLeft(node1)
        parent:SetRight(node2)

        table.insert(minHeap, parent)
        table.sort(minHeap, sortFunc)
    end

    self.root = parent
end

function HuffmanTree:__tostring()
    if nil == self.root then return end

    local levelStr = {}
    local function preOrder(level, node)
        if nil == node then return end

        local str = levelStr[level]
        if nil == str then
            str = {}
            levelStr[level] = str
        end
        table.insert(str, node.weight)

        preOrder(level+1, node.left)
        preOrder(level+1, node.right)
    end
    preOrder(1, self.root)
end

 

用20, 50, 10, 100构建的哈夫曼树：

function Test1()
    local hf = HuffmanTree.new()
    local nodeArr = {
        HuffmanTreeNode.new(20),
        HuffmanTreeNode.new(50),
        HuffmanTreeNode.new(10),
        HuffmanTreeNode.new(100),
    }
    hf:Build(nodeArr)
    tostring(hf)
end
Test1()

 

# 编码，先生成编码查询表，一般给左子树分配0，右子树分配1，所以编码后的查询表：

20 -> 001
50 -> 01
100 -> 1
10 -> 000

# 然后编码，就直接从这种查询表直接取编码值，查不到的就是没法编码的

function HuffmanTree:BuildCodes()
    self.codesQueryDict = {}
    local stack = {}

    local function preOrder(node)
        if nil == node then return end

        if node:IsLeaf() then
            self.codesQueryDict[node.value] = table.concat(stack)
            return
        end

        table.insert(stack, 0)
        preOrder(node.left)
        table.remove(stack, #stack)

        table.insert(stack, 1)
        preOrder(node.right)
        table.remove(stack, #stack)
    end
    preOrder(self.root)
end

function HuffmanTree:Encode(arr)
    local encodeBuilder = {}
    for i=1,#arr do
        local item = arr[i]
        local codes = self.codesQueryDict[item]
        if nil == codes then return nil end --编码失败
        table.insert(encodeBuilder, codes)
    end
    local byteStr = table.concat(encodeBuilder)
    return byteStr
end

 

# 解码，根据0为左子树，1为右子树，从根开始往下找，直到找到叶子节点；然后再从根往下找，不断重复。

function HuffmanTree:DecodeByString(byteStr)
    local decodeBuilder = {}
    local node = self.root
    local i = 1
    while true do
        local nodeIsLeaf = node:IsLeaf()
        if nodeIsLeaf then
            table.insert(decodeBuilder, node.value)
            node = self.root
        end

        if i > string.len(byteStr) then
            if not nodeIsLeaf then return end --解码错误
            break
        end

        local b = string.sub(byteStr, i, i)
        if "0" == b then node = node.left
        elseif "1" == b then node = node.right end
        i = i + 1
    end

    return table.concat(decodeBuilder)
end

 

# 测试代码

function Test1()
    local hf = HuffmanTree.new()
    local nodeArr = {
        HuffmanTreeNode.new(20),
        HuffmanTreeNode.new(50),
        HuffmanTreeNode.new(10),
        HuffmanTreeNode.new(100),
    }
    hf:Build(nodeArr)
    tostring(hf)

    hf:BuildCodes()
    local encodeStr = hf:Encode({10, 50})
    print(encodeStr)
    print(hf:DecodeByString(encodeStr))
end
Test1()

 

【其他参考】

数据结构——哈夫曼树（Huffman Tree） - 知乎 (zhihu.com)

详细图解哈夫曼Huffman编码树_无鞋童鞋的博客-CSDN博客_huffman编码树

Java 哈夫曼编码与解码_m0_38036210的博客-CSDN博客_java 哈夫曼解码

哈夫曼树以及哈夫曼编码和解码-Java实现 | 一个程序员的简单生活 (ddkiss.com)