Java与数据结构——赫夫曼编码

赫夫曼编码

        赫夫曼编码也称哈弗曼编码，是一种编码方式，属于一种程序算法，是哈夫曼树在通信中的经典应用之一。赫夫曼编码广泛地应用于数据文件压缩，其压缩率通常在 20%~90% ，是可变字长编码的一种。

 

赫夫曼编码实例：

（1）传输的字符串 i like like like java do you like a java

（2）统计字符使用频次： d:1  y:1  u:1  j:2  v:2  o:2  l:4  k:4  e:4  i:5  a:5  空格：9

 （3）按照字符出现的频数作为权值构建一棵赫夫曼树

步骤：

        1）将数据从小到大依次排序，每个数据是一个节点，每个节点看成一棵最简单的二叉树；

        2）取出节点权值最小的两棵二叉树；

        3）组成一棵新的二叉树，该新的二叉树的根节点的权值是前面两棵二叉树根节点权值的和；

        4）再将这棵新的二叉树，以根节点的权值大小再次排序，不断重复 1~4 的步骤，直到数列中所有的数据都被处理，就得到了一棵赫夫曼树。

（4）根据赫夫曼树，给各个字符规定编码（前缀编码），向左的路径为0，向右的路径为1，则对应的编码如下：

（5）按照上面的赫夫曼编码， 字符串  “i like like like java do you like a java”  对应的赫夫曼编码为：

（6）长度：133，原来的长度为359，压缩了（320-133）/320 = 58.44%，而且此编码满足前缀编码，即字符的编码不能是其他字符编码的前缀，不会造成匹配的多义性。

注意：赫夫曼编码是无损压缩，赫夫曼树根据排序方法不同对应的赫夫曼编码可能不同，但是对应的 wpl 是相同的，都是最小的，其赫夫曼编码的长度也是一样的。

功能：根据赫夫曼树压缩数据的原理，创建  “ i like like like java do you like a java”  对应的赫夫曼树。

思路：

（1）创建Node{  data（存放字符），weight（权值，字符频次），left，right  }；

（2）得到对应的byte[ ] 数组；

（3）编写一个方法，将准备构建赫夫曼树的节点放到 List，形式 { Node[data= 'a', weight = 5] , Node[data= ' ', weight = 9] , ......}，体现d:1  y:1  u:1  j:2  v:2  o:2  l:4  k:4  e:4  i:5  a:5  空格：9；

（4）可以通过 List 创建对应的赫夫曼树；

（5）根据赫夫曼树给各个字符进行编码；

（6）使用赫夫曼编码生产赫夫曼编码数据。

代码实现：

package heffmancode;

import java.util.*;

public class HuffmanCode {
    public static void main(String[] args) {
        String content = "i like like like java do you like a java";
        byte[] huffumanCodeBytes = huffumanZip(content);
        System.out.println("huffumanCodeBytes = " + Arrays.toString(huffumanCodeBytes) + "长度为：" + huffumanCodeBytes.length);//17个byte
        //压缩率  (40-17)/40 = 57.5%，因为添加了 133 % 8 = 3位
    }
    //!!!使用一个方法将前面的方法封装起来 便于调用 !!!
    //str: 原始字符串,  返回对应的压缩 byte[ ] 数组
    private static byte[] huffumanZip(String content){
        byte[] contentBytes = content.getBytes();//得到对应的byte[ ] 数组；
        //System.out.println(contentBytes.length);
        List<Node> nodes = getNodes(contentBytes);//将准备构建赫夫曼树的节点放到 nodes
        //System.out.println("nodes = " + nodes);
        Node huffmanTreeRoot = creatHuffmanTree(nodes);//通过 nodes 创建对应的赫夫曼树
        //huffmanTreeRoot.preOrder();//前序遍历
        //getCodes(huffmanTreeRoot,"",stringBuilder);
        //System.out.println("生成的赫夫曼编码表：" + hufumanCodes);
        //重载更简单
        Map<Byte, String> huffumanCodes1 = getCodes(huffmanTreeRoot);
        //System.out.println("生成的赫夫曼编码表：" + huffumanCodes1);
        byte[] huffumanCodeBytes = zip(contentBytes,huffumanCodes1);
        //System.out.println("huffumanCodeBytes = " + Arrays.toString(huffumanCodeBytes));//17个byte
        //压缩率  (40-17)/40 = 57.5%
        return huffumanCodeBytes;
    }
    private static List<Node> getNodes(byte[] bytes){
        //创建List存储节点信息
        List<Node> nodes = new ArrayList<>();
        //遍历bytes 统计每一个字符出现的次数
        Map<Byte,Integer> map = new HashMap<>();
        for (int i = 0; i < bytes.length; i++) {
            map.put(bytes[i], map.getOrDefault(bytes[i],0) + 1);
        }
        //System.out.println(map.toString());
        //把每个键值对转成一个Node对象，并加入到nodes集合
        for (Map.Entry<Byte,Integer> entry: map.entrySet()){
            nodes.add(new Node(entry.getKey(), entry.getValue()));
        }
        //System.out.println(nodes.toString());
        return nodes;
    }
    //通过 list 创建对应的赫夫曼树
    private static Node creatHuffmanTree(List<Node> nodes){
        while (nodes.size() > 1) {
            Collections.sort(nodes);//paix
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);
            Node parent = new Node(null,rightNode.weight + leftNode.weight);//根节点没有data，只有权值weight
            parent.left = leftNode;
            parent.right = rightNode;
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            nodes.add(parent);
        }
        return nodes.get(0);
    }
    //根据赫夫曼树生成对应的赫夫曼编码
    //思路：
    //1.将赫夫曼编码表存放在 Map<Byte, String>，如：[32,"01"]
    static Map<Byte, String> huffumanCodes = new HashMap<>();
    //2.在生成赫夫曼编码表时，需要去拼接路径，所以定义一个 StringBuilder 存储某个叶子节点的路径
    static StringBuilder stringBuilder = new StringBuilder();
    //将传入的 node 节点的所有叶子节点的赫夫曼编码得到，并放入到 hufumanCodes 集合
    //node: 传入节点    code: 路径，左子节点是0 右子节点是1
    private static void getCodes(Node node, String code, StringBuilder stringBuilder){
        StringBuilder stringBuilder1 = new StringBuilder(stringBuilder);
        //将code加入到stringBuilder1
        stringBuilder1.append(code);
        if (node != null){//node == null 不处理
            //判断当前node是叶子节点 还是非叶子节点
            if (node.data == null){
                //非叶子节点 向左递归再向右递归
                getCodes(node.left,"0",stringBuilder1);
                getCodes(node.right,"1",stringBuilder1);
            }else {
                //找到叶子节点 则向 hufumanCodes 存储对应信息
                huffumanCodes.put(node.data, stringBuilder1.toString());
            }
        }
    }
    //重载更简洁    赫夫曼树生成对应的赫夫曼编码
    private static Map<Byte,String> getCodes(Node root){
        if (root == null)
            return null;
        //处理左子树
        getCodes(root.left,"0",stringBuilder);
        //处理右子树
        getCodes(root.right,"1",stringBuilder);
        return huffumanCodes;
    }

    //编写一个方法，将一个字符串对应的byte[ ] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码压缩后的byte[ ]
    //bytes: 字符串对应的原始数组   hufumanCodes: 生成的赫夫曼编码表   返回赫夫曼编码表处理后的byte[ ]
    //返回的是对应的byte[] huffumanCodeBytes, 即 8 位对应一个byte，放入到 huffumanCodeBytes
    //huffumanCodeBytes[0] = 10101000(补码）变反码  10101000 - 1 = 10100111 ==>  11011000 = -88
    //huffumanCodeBytes[0] = -88
    private static byte[] zip(byte[] bytes, Map<Byte,String> huffumanCodes){
        //1. 利用 huffumanCodes 将 bytes 转成 赫夫曼编码对应的字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (byte b: bytes){
            stringBuilder.append(huffumanCodes.get(b));
        }
        //将“1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100”转换成bytes
        //统计返回的 byte[ ] huffumanCodeBytes 长度
        //一句话 int len = (stringBuilder.length() + 7) / 8;
        int len;
        if (stringBuilder.length() % 8 ==0){
            len = stringBuilder.length() / 8;
        }else {
            len = stringBuilder.length() / 8 + 1;
        }
        //创建存储压缩的 byte 数组
        byte[] huffumanCodeBytes = new byte[len];
        int index = 0;
        for (int i = 0; i < stringBuilder.length(); i += 8){
            String strByte;
            if (i + 8 > stringBuilder.length()){
                strByte = stringBuilder.substring(i);
            }else{
                strByte = stringBuilder.substring(i,i+8);
            }
            //将strByte 转成一个 byte 放入到 huffumanCodeBytes
            huffumanCodeBytes[index] = (byte) Integer.parseInt(strByte,2);
            index++;
        }
        return huffumanCodeBytes;
    }
}
//创建Node，带入数据和权值
class Node implements Comparable<Node>{
    Byte data;//存放数据本身，比如 'a' ==> 97, ' ' ==> 32
    int weight;//权值，表示字符出现的次数
    Node left;
    Node right;
    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    @Override
    public int compareTo(Node o) {
        //从小到大排序
        return this.weight - o.weight;
    }

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