Huffman编码和解码

一.Huffman树

定义:　 给定n个权值作为n个叶子结点,构造一棵二叉树,若该树的带权路径达到最小,这样的二叉树称为最优二叉树,也称为霍夫曼树(Huffman树).

特点:     Huffman树是带权路径长度最短的树,权值较大的节点离根节点较近

　　　　权值 = 当前节点的值 * 层数,wpl最小的值,就是Huffman树

创建步骤  举例  {13,7,8,3,29,6,1}

　　　　1.从小到大进行排序,将每一个数据视为一个节点,每一个节点都可视为一个二叉树

　　　　2.取出根节点权值两个最小的二叉树

　　　　3.组成一个新的二叉树,新的二叉树根节点的权值是前面两颗二叉树节点权值之和

　　　　4.再将这颗二叉树以根节点的权值大小进行再排序,不断重复1,2,3,4步,直到所有的数据都被处理,就得到一个Huffman树

class Node implements Comparable<Node> {
   // 实现Comparable接口,可以使用Collections工具类进行排序
    public int value;
    public Node left;
    public Node right;

    public Node(int value) {
        this.value = value;
    }

    public Node() {
    }

    /*用于测试Huffman树是否正确*/
    public void preOrder(){
        System.out.println(this);
        if (this.left != null){
            this.left.preOrder();
        }
        if (this.right != null){
            this.right.preOrder();
        }
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }

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

 /**
     * 创建霍夫曼树
     * @param array 原数组
     * @return 创建好Huffman树的root节点
     */
    public static Node createHuffmanTree(int[] array){
        if (array.length == 0 || array == null){
            System.out.println("数组为空,无法创建");
            return null;
        }
        /*遍历数组中的每一个元素,构造成Node,放入到List中*/
        List<Node> nodes = new ArrayList<>();
        for (int item : array) {
            nodes.add(new Node(item));
        }

        while (nodes.size() > 1){ /*只要List中有元素,就一直进行权值计算*/
            /*对Node进行排序*/
            Collections.sort(nodes);

            /*取出根节点两个权值最小的二叉树*/
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);

            /*构建一个新的二叉树*/
            Node parent = new Node(leftNode.value + rightNode.value);
            parent.left = leftNode;
            parent.right = rightNode;

            /*从List中删除使用过的节点*/
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            /*将新的节点加入到List中*/
            nodes.add(parent);
        }
        /*返回Huffman树的root节点*/
        return nodes.get(0);
    }
}    

测试,如果生成的Huffman树是正确的,那么前序遍历的结果也是正确的

public static void main(String[] args) {
        int[] array = {13,7,8,3,29,6,1};
        preOrder(createHuffmanTree(array));
    }

    public static void preOrder(Node root){
        if (root != null){
            root.preOrder();
        }else {
            System.out.println("该树为空,不能遍历");
            return;
        }
    }

二.Huffman编码

定义:　   Huffman编码是一种通信的编码,是在电通信领域的基本编码之一

作用:　　Huffman编码广泛的应用于数据文件的压缩,而且它是前缀编码,可以有效的节省传输的带宽

编码的步骤:     举例  String content = 'i like like like java do you like a java oh oh oh';

　　1.生成节点　　　

/*定义节点,data用于存放数据,weight用于存放权值*/
class HuffmanNode implements Comparable<HuffmanNode>{
    public Byte data;
    public int weight;
    public HuffmanNode left;
    public HuffmanNode right;

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

    public HuffmanNode() {
    }

    @Override
    public int compareTo(HuffmanNode o) {
        return this.weight - o.weight;
    }

}

　　2.统计字符串中每一个字符出现的次数

/*统计字符串中每个字符出现的次数,放在List中进行返回*/
/*List存储格式 [Node[date=97 ,weight = 5], Node[date=32,weight = 9]......]*/
public static List<HuffmanNode> getNodes(byte[] bytes){
        if (bytes.length == 0 || bytes == null){
            System.out.println("字符串为空,无法进行编码");
            return null;
        }
        List<HuffmanNode> nodes = new ArrayList<>();
        Map<Byte,Integer> counts = new HashMap<>();
        /*遍历bytes ,统计每一个byte出现的次数*/
        for (byte item : bytes) {
           Integer count = counts.get(item);
           if (count == null){ // Map中没有这个字符,说明是第一次
               counts.put(item,1);
           }else {
               counts.put(item,count+1);
           }
        }
         /*遍历Map,将键值对转换为Node对象进行存放到List中*/
        for (Map.Entry<Byte,Integer> node:counts.entrySet()){
            nodes.add(new HuffmanNode(node.getKey(),node.getValue()));
        }
        return nodes;
    }

　　3.根据List集合,创建Huffm树

public static HuffmanNode createHuffmanTree(List<HuffmanNode> nodes){
        if (nodes.size() == 0 || nodes == null){
            System.out.println("生成的List为空,不能生成霍夫曼树");
            return null;
        }
        while (nodes.size() > 1){
            Collections.sort(nodes);

            HuffmanNode leftNode = nodes.get(0);
            HuffmanNode rightNode = nodes.get(1);
            HuffmanNode parent = new HuffmanNode(null,leftNode.weight+rightNode.weight);

            parent.left = leftNode;
            parent.right = rightNode;

            nodes.remove(leftNode);
            nodes.remove(rightNode);
            nodes.add(parent);

        }
        return nodes.get(0);
    }

　　4.将传入的Huffman树进行Huffman编码

/*将传入所有节点的Node节点的Huffman编码得到*/
/*node 传入的节点*/
/*code 路径,向左为0,向右为1*/
/*StringBuild 用于拼接路径,生成编码*/
public static void getCode(HuffmanNode node,String code,StringBuilder stringBuilder){
        StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
        /*将code加入到stringBuilder2 中*/
        stringBuilder2.append(code);
        if (node!=null){ // 如果node是null,则不进行处理
            if (node.data == null){ // 是非叶子节点
                //向左递归
                getCode(node.left,"0",stringBuilder2);
                //向右递归
                getCode(node.right,"1",stringBuilder2);
            }else { /*此时表明是叶子结点,说明找到了一条路径的最后*/
                huffmanCode.put(node.data,stringBuilder2.toString());
            }
        }
    }

/*方便调用,重载此方法*/
public static Map<Byte,String> getCode(HuffmanNode root){
        if (root == null){
            System.out.println("没有生成霍夫曼树");
            return null;
        }else {
            /*处理root左子树*/
            getCode(root.left,"0",stringBuilder);
            /*处理root右子树*/
            getCode(root.right,"1",stringBuilder);
        }
        return huffmanCode;
    }

　　5.使用Huffman编码进行压缩

/*将字符串对应的byte数组,通过生成的Huffman编码表,返回一个Huffman编码压缩后的byte数组*/
/*bytes 原始字符串对应的字节数组*/
/*huffmanCode 生成的Huffman编码表*/
/* 返回Huffman编码处理后的字节数组*/
public static byte[] zip(byte[] bytes,Map<Byte,String> huffmanCode){
        if (bytes.length == 0 || bytes == null){
            System.out.println("字符串为空,无法进行编码");
            return null;
        }
        /*1.根据HuffmanCode获取原始的字节数组的二进制的字符串*/
        StringBuilder stb = new StringBuilder();
        for (byte b : bytes) {
            stb.append(huffmanCode.get(b));
        }
        /*2.创建存储压缩后的字节数组*/
        int index = 0; //记录第几个byte
        int len = 0; // 确定霍夫曼编码的长度
        if (stb.length() % 8 == 0){
            len = stb.length() / 8;
        }else {
            len = stb.length() / 8 + 1;
        }
        byte[] huffmanCodeBytes = new byte[len];
        /*每8位对应一个byte,所以步长+8*/
        for (int i = 0; i < stb.length();i+=8){
            String strByte = null;
            if (i+8 > stb.length()){ // 不够8位,直接从当前截取到末尾
                strByte = stb.substring(i);
            }else {
                strByte = stb.substring(i,i+8); //否则按照每8位进行拼接
            }
            /*将strByte 转换成一个个byte,放在要返回的字节数组中,进行返回*/
            huffmanCodeBytes[index++] = (byte)Integer.parseInt(strByte,2);
        }
        return huffmanCodeBytes;
    }

查看编码的结果:   压缩率   (49-21) / 49 = 57.14%

压缩之后的字节数组是:

将上述Huffman编码的步骤封装

public static byte[] getZip(byte[] bytes){
        List<HuffmanNode> nodes = getNodes(bytes);
        // 根据nodes创建赫夫曼树
        HuffmanNode root = createHuffmanTree(nodes);
        // 根据root节点生成霍夫曼编码
        huffmanCode = getCode(root);
        // 根据霍夫曼编码,对数据进行压缩,得到字节数组
        byte[] huffmanCodeBytes = zip(bytes,huffmanCode);
       // System.out.println(Arrays.toString(huffmanCodeBytes));
        return huffmanCodeBytes;
    }

三.使用Huffman进行解码

　 1.将一个二进制的byte,装换为二进制的字符串

/**
     * 将一个byte转换成二进制的字符串
     * @param flag 表示是否要进行补高位,如果是true则需要补高位,false则不需要补位,如果是最后一个字节不需要补高位
     * @param b
     * @return  是该byte对应的二进制字符串(补码返回)
     */
    public static String byteToBitString(boolean flag,byte b){
        int temp = b;  /* 使用临时变量,将byte转换为int*/
        if (flag){ /*如果是一个正数,需要进行补位操作*/
            temp |= 256; /*按位与操作*/
        }
        String str = Integer.toBinaryString(temp); /*返回temp对应的二进制补码*/
        if (flag){ // 如果有8位,则按照8位来返回,否则直接返回字符串
            return str.substring(str.length()-8);
        }else {
            return str;
        }
    }

　　2.解码操作

 /**
     *
     * @param huffmanCode   对应霍夫曼编码表
     * @param huffmanBytes  霍夫曼编码得到的字节数组
     * @return 原先字符串对应的字节数组
     */
    public static byte[] decode(Map<Byte,String> huffmanCode,byte[] huffmanBytes){
        /*1.先得到HuffmanBytes对应的二进制的字符串*/
        StringBuilder sbt = new StringBuilder();
        //将byte字节转换为二进制字符串
        for (int i = 0; i < huffmanBytes.length; i++) {
            byte b = huffmanBytes[i];
            // 判断是否是最后一个字节
            boolean flag = (i == huffmanBytes.length-1);
            sbt.append(byteToBitString(!flag,b));
        }

        /*2.把字符串按照指定的方式进行霍夫曼解码*/
        /*把Huffman码表进行调换,因为是反向查询*/
        Map<String,Byte> map = new HashMap<>();
        for (Map.Entry<Byte,String> entry:huffmanCode.entrySet()){
            map.put(entry.getValue(),entry.getKey());
        }

        /*3.创建集合,存放解码后的byte*/
        List<Byte> byteList = new ArrayList<>();
        /*使用索引不停的扫描stb*/
        for (int k = 0; k < sbt.length();){
            int count = 1;  /*小的计数器,用于判断是否字符串是否在Huffman的码标中*/
            Byte b = null;  /*用于存放编码后的字节*/
            boolean loop = true;
            while (loop){
                /*k不动,让count进行移动,指定匹配到一个字符*/
                String key = sbt.substring(k,k+count);
                b = map.get(key);
                if (b == null){ //没有匹配到
                    count++;
                }else {
                    //匹配到就退出循环
                    loop = false;
                }
            }
            byteList.add(b);
            k += count;  //k直接移动到count在进行下一次遍历
        }

        /*4.当for循环结束后,将list中存放的数据放入到byte数组中返回即可*/
        byte[] decodeByteCodes = new byte[byteList.size()];
        for (int j = 0; j < decodeByteCodes.length; j++) {
            decodeByteCodes[j] = byteList.get(j);
        }
        return decodeByteCodes;
    }

查看解码后的结果:

完整代码

package data.structer.tree;

import java.util.*;

public class HuffmanCodeDemo {

    static Map<Byte,String> huffmanCode = new HashMap<>();
    static StringBuilder stringBuilder = new StringBuilder();

    public static void main(String[] args) {
        String content = "i like like like java do you like a java oh oh oh";
        //System.out.println("原始的长度是:"+content.length());

        byte[] bytes = getZip(content.getBytes());
       // System.out.println("Huffman编码后的字符串长度是:"+bytes.length);
        System.out.println("解码后的字符串是:"+new String(decode(huffmanCode,bytes)));
    }

    // 解码

    /**
     *
     * @param huffmanCode   对应霍夫曼编码表
     * @param huffmanBytes  霍夫曼编码得到的字节数组
     * @return
     */
    public static byte[] decode(Map<Byte,String> huffmanCode,byte[] huffmanBytes){
        StringBuilder sbt = new StringBuilder();
        //将byte字节转换为二进制字符串
        for (int i = 0; i < huffmanBytes.length; i++) {
            byte b = huffmanBytes[i];
            // 判断是否是最后一个字节
            boolean flag = (i == huffmanBytes.length-1);
            sbt.append(byteToBitString(!flag,b));
        }

        //把字符串按照指定的方式进行霍夫曼解码
        Map<String,Byte> map = new HashMap<>();
        for (Map.Entry<Byte,String> entry:huffmanCode.entrySet()){
            map.put(entry.getValue(),entry.getKey());
        }

        // 创建集合,存放byte
        List<Byte> byteList = new ArrayList<>();
        for (int k = 0; k < sbt.length();){
            int count = 1;
            Byte b = null;
            boolean loop = true;
            while (loop){
                String key = sbt.substring(k,k+count);
                b = map.get(key);
                if (b == null){ //没有匹配到
                    count++;
                }else {
                    loop = false;
                }
            }
            byteList.add(b);
            k += count;
        }

        byte[] decodeByteCodes = new byte[byteList.size()];
        for (int j = 0; j < decodeByteCodes.length; j++) {
            decodeByteCodes[j] = byteList.get(j);
        }
        return decodeByteCodes;
    }

    /**
     * 将一个byte转换成二进制的字符串
     * @param flag 表示是否要进行补高位,如果是true则需要补高位,false则不需要补位,如果是最后一个字节不需要补高位
     * @param b
     * @return  是该byte对应的二进制字符串(补码返回)
     */
    public static String byteToBitString(boolean flag,byte b){
        int temp = b;
        if (flag){
            temp |= 256;
        }
        String str = Integer.toBinaryString(temp);
        if (flag){
            return str.substring(str.length()-8);
        }else {
            return str;
        }
    }

    public static byte[] getZip(byte[] bytes){
        List<HuffmanNode> nodes = getNodes(bytes);
        // 根据nodes创建赫夫曼树
        HuffmanNode root = createHuffmanTree(nodes);
        // 根据root节点生成霍夫曼编码
        huffmanCode = getCode(root);
        // 根据霍夫曼编码,对数据进行压缩,得到字节数组
        byte[] huffmanCodeBytes = zip(bytes,huffmanCode);
       // System.out.println(Arrays.toString(huffmanCodeBytes));
        return huffmanCodeBytes;
    }

    /**
     * 统计字符串中每个字符出现的次数,添加到List中进行返回
     * @param bytes
     * @return
     */
    public static List<HuffmanNode> getNodes(byte[] bytes){
        if (bytes.length == 0 || bytes == null){
            System.out.println("字符串为空,无法进行编码");
            return null;
        }
        List<HuffmanNode> nodes = new ArrayList<>();
        Map<Byte,Integer> counts = new HashMap<>();

        for (byte item : bytes) {
           Integer count = counts.get(item);
           if (count == null){ // 说明是第一次
               counts.put(item,1);
           }else {
               counts.put(item,count+1);
           }
        }

        for (Map.Entry<Byte,Integer> node:counts.entrySet()){
            nodes.add(new HuffmanNode(node.getKey(),node.getValue()));
        }
        return nodes;
    }

    /**
     * 使用霍夫曼编码进行压缩
     * @param bytes
     * @param huffmanCode
     * @return
     */
    public static byte[] zip(byte[] bytes,Map<Byte,String> huffmanCode){
        if (bytes.length == 0 || bytes == null){
            System.out.println("字符串为空,无法进行编码");
            return null;
        }
        StringBuilder stb = new StringBuilder();
        for (byte b : bytes) {
            stb.append(huffmanCode.get(b));
        }
        int index = 0;
        int len = 0; // 确定霍夫曼编码的长度
        if (stb.length() % 8 == 0){
            len = stb.length() / 8;
        }else {
            len = stb.length() / 8 + 1;
        }
        byte[] huffmanCodeBytes = new byte[len];

        for (int i = 0; i < stb.length();i+=8){
            String strByte = null;
            if (i+8 > stb.length()){ // 不够8位
                strByte = stb.substring(i);
            }else {
                strByte = stb.substring(i,i+8);
            }
            huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte,2);
            index++;
        }
        return huffmanCodeBytes;
    }

    public static void getCode(HuffmanNode node,String code,StringBuilder stringBuilder){
        StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
        stringBuilder2.append(code);
        if (node!=null){
            if (node.data == null){ // 是非叶子节点
                //向左递归
                getCode(node.left,"0",stringBuilder2);
                //向右递归
                getCode(node.right,"1",stringBuilder2);
            }else {
                huffmanCode.put(node.data,stringBuilder2.toString());
            }
        }
    }

    public static Map<Byte,String> getCode(HuffmanNode root){
        if (root == null){
            System.out.println("没有生成霍夫曼树");
            return null;
        }else {
            getCode(root.left,"0",stringBuilder);
            getCode(root.right,"1",stringBuilder);
        }
        return huffmanCode;
    }

    /**
     * 生成霍夫曼树
     * @param nodes
     * @return
     */
    public static HuffmanNode createHuffmanTree(List<HuffmanNode> nodes){
        if (nodes.size() == 0 || nodes == null){
            System.out.println("生成的List为空,不能生成霍夫曼树");
            return null;
        }
        while (nodes.size() > 1){
            Collections.sort(nodes);

            HuffmanNode leftNode = nodes.get(0);
            HuffmanNode rightNode = nodes.get(1);
            HuffmanNode parent = new HuffmanNode(null,leftNode.weight+rightNode.weight);

            parent.left = leftNode;
            parent.right = rightNode;

            nodes.remove(leftNode);
            nodes.remove(rightNode);
            nodes.add(parent);

        }
        return nodes.get(0);
    }
}

class HuffmanNode implements Comparable<HuffmanNode>{
    public Byte data;
    public int weight;
    public HuffmanNode left;
    public HuffmanNode right;

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

    public HuffmanNode() {
    }

    @Override
    public String toString() {
        return "HuffmanNode{" +
                "data=" + data +
                ", weight=" + weight +
                '}';
    }

    @Override
    public int compareTo(HuffmanNode o) {
        return this.weight - o.weight;
    }

}