赫夫曼编码

哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。

哈夫曼编码，主要目的是根据使用频率来最大化节省字符（编码）的存储空间。

哈夫曼编码的原理就是基于哈夫曼树

哈夫曼树相关的几个名词

路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。

路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。

结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。

结点的带权路径长度：指的是从根结点到该结点之间的路径长度与该结点的权的乘积。例如，图 1 中结点 b 的带权路径长度为 2 * 5 = 10 。

树的带权路径长度为树中所有叶子结点的带权路径长度之和。通常记作 “WPL” 。例如图 1 中所示的这颗树的带权路径长度为：

WPL = 7 * 1 + 5 * 2 + 2 * 3 + 4 * 3

什么是哈夫曼树

当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。

在构建哈弗曼树时，要使树的带权路径长度最小，只需要遵循一个原则，那就是：权重越大的结点离树根越近。在图 1 中，因为结点 a 的权值最大，所以理应直接作为根结点的孩子结点。

构建哈夫曼树

对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法：

第一步：我们创建节点类，这些值作为节点的权值，存储在集合里。

第二步：将这些节点按照权值的大小进行排序。

第三步：取出权值最小的两个节点，并创建一个新的节点作为这两个节点的父节点，这个父节点的权值为两个子节点的权值之和。将这两个节点分别赋给父节点的左右节点。

 第四步：删除这两个节点，将父节点添加进集合里。

 

 第五步：重复第二步到第四步，直到集合中只剩一个元素，结束循环。

 

 哈夫曼编码过程:

1 将字符串转换为byte数组

2 检查byte数组中字符的出现次数，将字符的byte和字符出现次数保存为节点，放入集合中

3 构建哈夫曼树

4 设左路径为0 右路径为1 计算字符的哈夫曼编码值，存入Map集合中

5 参照Map集合，将byte数组转换为byte字符串，将其对照Map集合逐一处理，由于数据量较大，所以八位一组进行数据压缩

package com.qyx;
import java.lang.reflect.Array;
import java.util.*;
/**
 * 赫夫曼编码
 */
public class HuffmanCode {
    public static void main(String[] args){
        String str="i like java forever";
        byte[] bytes=str.getBytes();
        byte[] bys=huffmanZip(bytes);
        System.out.println(Arrays.toString(bys));
    }
    private static List<Node> getNodes(byte[] bytes)
    {
        //1 创建ArrayList
        ArrayList<Node> list=new ArrayList<Node>();
        //遍历bytes,统计存储每个byte出现的次数->map
        Map<Byte,Integer> counts=new HashMap<Byte, Integer>();
        for(byte b:bytes)
        {
            Integer count=counts.get(b);
            if (count==null)
            {
                counts.put(b,1);
            }else {
                counts.put(b, count + 1);
            }
        }
        //把每个键值对转化成一个Node对象，并放入到nodes集合中
        for (Map.Entry<Byte,Integer> entry:counts.entrySet())
        {
            list.add(new Node(entry.getKey(),entry.getValue()));
        }
        return list;
    }
    //通过List创建对应的哈夫曼树
    private static Node createHuffManTree(List<Node> list)
    {
        while (list.size()>1)
        {
            //排序,从小到大，根据我们实现的compareTo方法来决定的
            Collections.sort(list);
            Node leftNode=list.get(0);
            Node rightNode=list.get(1);
            //新的根节点没有data，只有权值
            Node parent=new Node(null,leftNode.weight+rightNode.weight);
            parent.left=leftNode;
            parent.right=rightNode;
            //将已经处理的两颗二叉树从list移除
            list.remove(leftNode);
            list.remove(rightNode);
            list.add(parent);
        }
        return list.get(0);
    }
    //生成哈夫曼树对应的哈夫曼编码表

    /**
     * 思路:
     * 1 将赫夫曼编码表存放在Map<Byte,String>中
     * 2 在生成赫夫曼编码表示，需要去拼接路径，定义一个StringBuilder
     * 存储某个叶子节点的路径
     * @param
     */
    private static Map<Byte,String> huffmanCodes=new HashMap<Byte, String>();
    private static StringBuilder builder=new StringBuilder();

    /**
     * 功能:将传入的node结点的所有叶子节点的赫夫曼编码得到，并放入到huffmanCode的集合中
     * @param node 传入节点
     * @param code 路径：左子节点是0，右子节点是1
     * @param builder 用于拼接路径
     */
    private static void getCodes(Node node,String code,StringBuilder builder)
    {
        StringBuilder builder1=new StringBuilder(builder);
        //将code加入到builder1
        builder1.append(code);
        if (node!=null)
        {
            //判断当前node是叶子节点还是非叶子节点
            if(node.data==null)
            {
                //非叶子节点,则需要递归
                //向左递归
                getCodes(node.left,"0",builder1);
                //向右递归
                getCodes(node.right,"1",builder1);
            }else{
                //说明是一个叶子节点
                huffmanCodes.put(node.data,builder1.toString());
            }
        }
    }
    //为了调用方便，重载getCodes
    private static Map<Byte,String> getCodes(Node root)
    {
        if (root==null)
        {
            return null;
        }
        //处理root的左子树
        getCodes(root.left,"0",builder);
        //处理root的右子树
        getCodes(root.right,"1",builder);
        return huffmanCodes;
    }
    //编写一个方法，将字符串对应的byte[]数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]

    /**
     *
     * @param bytes 这是原始的字符串生成byte数组
     * @param huffmanCodes 这是字符对应的赫夫曼编码的map
     * @return  返回赫夫曼编码处理后的字符数组
     */
    private static byte[] zip(byte[] bytes,Map<Byte,String>huffmanCodes)
    {
        //1 利用huffmanCodes将bytes转成转成赫夫曼编码对应的字符串
        StringBuilder stringBuilder=new StringBuilder();
        //遍历bytes数组
        for(byte b:bytes)
        {
            stringBuilder.append(huffmanCodes.get(b));
        }
        //System.out.println("测试stringBuilder="+stringBuilder.toString());
        //将赫夫曼字符串转成byte[]
        int len;
        if (stringBuilder.length()%8==0)
        {
            len=stringBuilder.length()/8;
        }else {
            len=stringBuilder.length()/8+1;
        }
        //创建 存储压缩后的byte数组
        byte[] by=new byte[len];
        int index=0;//记录是第几个byte
        for (int i=0;i<stringBuilder.length();i+=8)
        {
            //因为是每8位对应一个byte，所有步长+8
            String strByte;
            if (i+8>stringBuilder.length())
            {
                //不够8位
                strByte=stringBuilder.substring(i);
            }else {
                strByte = stringBuilder.substring(i, i + 8);
            }
            //将strByte转成byte数组，放入到by
            by[index]= (byte) Integer.parseInt(strByte,2);
            index++;
        }
        return by;
    }
    //使用一个方法，将前面的方法封装起来，便于调用

    /**
     *
     * @param bytes 原始的字符串对应的字节数组
     * @return 经历赫夫曼编码处理的字节数组
     */
    private static byte[] huffmanZip(byte[] bytes)
    {
        List<Node> nodes=getNodes(bytes);
        //创建赫夫曼树
        Node root=createHuffManTree(nodes);
        //生成对应的赫夫曼编码(根据赫夫曼树)
        Map<Byte,String> huffmanCodes=getCodes(root);
        //根据赫夫曼编码对原始的数组进行压缩
        byte[] huffmanCodeBytes=zip(bytes,huffmanCodes);
        return huffmanCodeBytes;
    }
    //前序遍历
    private static void preOrder(Node root)
    {
        if (root!=null)
        {
            root.preOrder();
        }else{
            System.out.println("哈夫曼树为空");
        }
    }
}
class Node implements Comparable<Node>{
    Byte data;//存放数据 a=97
    int weight;//权值，字符出现次数
    Node left;
    Node right;

    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    @Override
    public int compareTo(Node node) {
        return this.weight-node.weight;
    }
    //重新toString

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", weight=" + weight +
                '}';
    }
    //前序遍历
    public void preOrder(){
        System.out.println(this);
        if(this.left!=null)
        {
            this.left.preOrder();;
        }
        if(this.right!=null)
        {
            this.right.preOrder();
        }
    }
}