Huffman

霍夫曼编码的实现

霍夫曼编码

理论概述

引用维基百科中的描述如下：

霍夫曼编码（英语：Huffman Coding），又译为哈夫曼编码、赫夫曼编码，是一种用于无损数据压缩的熵编码（权编码）算法。由大卫·霍夫曼在1952年发明。

在计算机数据处理中，霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现概率的方法得到的，出现概率高的字母使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

例如，在英文中，e的出现概率最高，而z的出现概率则最低。当利用霍夫曼编码对一篇英文进行压缩时，e极有可能用一个比特来表示，而z则可能花去25个比特（不是26）。用普通的表示方法时，每个英文字母均占用一个字节，即8个比特。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为WPL=（W1*L1+W2*L2+W3*L3+…+Wn*Ln），N个权值Wi（i=1,2,…n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,…n）。可以证明霍夫曼树的WPL是最小的。

霍夫曼算法

计算霍夫曼编码首先需要创建一棵霍夫曼树，而创建树的算法基于贪心的思想：

1. 将所有叶子节点加入优先级队列中（频率从小到大排序）
2. 每次从队列头部取出两个节点，然后创建 一个新的节点，其孩子为这两个节点，值为二者频率的和。依次进行直到只剩下一个根节点即可。

注意，最优二叉树不是唯一的，为了编码解码唯一，所以，我在实现过程中加了一个判断条件，保证左子树永远小于等于右子树，另外比如对于2,3,5的情况，2和3作为孩子的父节点作为左子树，右子树是5。

有了以上规定，并且编码左子树为0，右子树为1.这样的解是唯一的。

代码实现

package Huffman;import java.util.*;public class code{    static class node implements Comparable<node>    {        int val;        node left;        node right;        int position; //为了保证huffman树的唯一性        node()        {            this.val=-1;            this.left=null;            this.right=null;        }        node(int val)        {            this.val=val;            this.left=null;            this.right=null;        }        @Override        public int compareTo(node o)        {            if (this.val!=o.val)                return this.val-o.val;            else                return this.position-o.position;        }    }    public static void main(String[] args)    {        Scanner in = new Scanner(System.in);        Queue<node> q=new PriorityQueue<>();        int n=in.nextInt();        for (int i=1;i<=n;i++)        {            node tmp=new node();            tmp.val=in.nextInt();            tmp.position=i;            q.add(tmp);        }        while (q.size()>1)        {            node L=q.poll();            node R=q.poll();            node tmp=new node(L.val+R.val);            tmp.left=L;            tmp.right=R;            tmp.position=L.position;            q.add(tmp);        }        res=new HashMap<>();        encode(q.peek(),new ArrayList<>());        for (Integer e:res.keySet())            System.out.println(e+"编码为:"+res.get(e));        List<Integer> tobedecode=new ArrayList<>();        System.out.println("请输入欲解码的编码");        String tmp=in.next();        for (int i=0;i<tmp.length();i++)            tobedecode.add(tmp.charAt(i)-'0');//        System.out.println(tobedecode);        try        {            decode(q.peek(),tobedecode);        }        catch (AssertionError e)        {            System.out.println(e.getMessage());        }    }    private static Map<Integer,List<Integer>> res;    private static void encode(node root,List<Integer> prefix)    {//回溯法打印编码        if (root.right==null&&root.left==null)        {            res.put(root.val,new ArrayList<>(prefix));        }        else        {            prefix.add(0);            encode(root.left,prefix);            prefix.remove(prefix.size()-1);            prefix.add(1);            encode(root.right,prefix);            prefix.remove(prefix.size()-1);        }    }    private static void decode(node root,List<Integer> prefix)    {//解码prefix        if (prefix.size()==0&&root.left==null&&root.right==null)            System.out.println("该编码表示字符的优先级为"+root.val);        else if (prefix.size()>0&&prefix.get(0)==0&&root.left!=null)        {            prefix.remove(0);            decode(root.left,prefix);        }        else if (prefix.size()>0&&prefix.get(0)==1&&root.right!=null)        {            prefix.remove(0);            decode(root.right,prefix);        }        else        {            throw new AssertionError("未能识别的编码");        }    }    private static void print(node root)    {//先序遍历huffman树，debug用        if (root==null)            return;        else        {            System.out.print(root.val+"  ");            print(root.left);            print(root.right);        }    }}

思路很简单，最后加了个先序遍历是为了debug。可以不实现它。

编码过程用了回溯的思想（说白了就是DFS），解码就很简单了，直接从根出发即可。