赫夫曼树

1 前言

霍夫曼树是二叉树的一种特殊形式，又称为最优二叉树，其主要作用在于数据压缩和编码长度的优化。

2 重要概念

2.1 路径和路径长度

在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。

 

图2.1

图2.1所示二叉树结点A到结点D的路径长度为2，结点A到达结点C的路径长度为1。

2.2 结点的权及带权路径长度

若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。
图2.2展示了一棵带权的二叉树

 

图2.2

2.3 树的带权路径长度

树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。
图2.2所示二叉树的WPL：
WPL = 6 * 2 + 3 * 2 + 8 * 2 = 34；

3 霍夫曼树

3.1 定义

给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为霍夫曼树(Huffman Tree)。
如图3.1所示两棵二叉树

 

图3.1

叶子结点为A、B、C、D，对应权值分别为7、5、2、4。
3.1.a树的WPL = 7 * 2 + 5 * 2 + 2 * 2 + 4 * 2 = 36
3.1.b树的WPL = 7 * 1 + 5 * 2 + 2 * 3 + 4 * 3 = 35
由ABCD构成叶子结点的二叉树形态有许多种，但是WPL最小的树只有3.1.b所示的形态。则3.1.b树为一棵霍夫曼树。

3.2 构造霍夫曼树

构造霍夫曼树主要运用于编码，称为霍夫曼编码。现考虑使用3.1中ABCD结点以及对应的权值构成如下长度编码。
AACBCAADDBBADDAABB。
编码规则:从根节点出发，向左标记为0，向右标记为1。
采用上述编码规则，将图3.1编码为图3.2所示：

 

图3.2

构造过程：
3.1.a所示二叉树称为等长编码，由于共有4个结点，故需要2位编码来表示，编码结果为：

结点	编码
A	00
B	01
C	10
D	11

则AACBCAADDBBADDAABB对应编码为：
00 00 10 01 10 00 00 11 11 01 01 00 11 11 00 00 01 01
长度为36。
3.1.b构造过程如下：
1）选择结点权值最小的两个结点构成一棵二叉树如图3.3：

 

图3.3

2）则现在可以看作由T1，A，B构造霍夫曼树，继续执行步骤1。
选则B和T1构成一棵二叉树如图3.4：

 

图3.4

3）现只有T2和A两个结点，继续执行步骤1。
选择A和T2构成一棵二叉树如图3.5：

 

图3.5

经过上述步骤则可以构造完一棵霍夫曼树。通过观察可以发现，霍夫曼树中权值越大的结点距离根结点越近。
按照图3.5霍夫曼树编码结果：

结点	编码
A	0
B	10
C	110
D	111

则AACBCAADDBBADDAABB对应编码为：
0 0 110 10 110 0 0 111 111 10 10 0 111 111 0 0 10 10
编码长度为35。
由此可见，采用二叉树可以适当降低编码长度，尤其是在编码长度较长，且权值分布不均匀时，采用霍夫曼编码可以大大缩短编码长度。

4.代码实现

1.创建结点

public class Node implements Comparable<Node>  {
    int value;
    Node left;//左节点
    Node right;//右节点

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

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


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


    /*前序遍历*/

    public  void  preOrder(){
        System.out.println(this);
        if (this.left!=null){
              this.left.preOrder();
        }
        if (this.right!=null){
            this.right.preOrder();
        }
    }
}

2.创建霍夫曼树

public class HuffmanTree {

    public static void main(String[] args) {
        int[] arr = {13,7,8,3,29,6,1};
        //1.数组进行升序排序
        Node root = createHuffmanTree(arr);
        preOrder(root);

    }

   /*创建赫夫曼树*/
    public  static  Node createHuffmanTree(int[] arr){
        //数组进行升序排序
        ArrayList<Node> list = new ArrayList<>();
        for (int item : arr) {
            Node node = new Node(item);
            list.add(node);
        }
        while (list.size()>1){
            Collections.sort(list);
            //System.out.println("list ="+list);
            /*取出权值最小的二叉树*/
            Node leftNo = list.get(0);
            /*取出第二小的*/
            Node rightNo = list.get(1);
            /*构建新得二叉树*/
            Node parent = new Node(leftNo.value+rightNo.value);
            parent.left=leftNo;
            parent.right=rightNo;
            //删除list删除掉处理的二叉树
            list.remove(leftNo);
            list.remove(rightNo);
            //将父节点加入到list
            list.add(parent);

           // System.out.println("第一次处理" +list);
        }
        return list.get(0); //返回赫夫曼数的root节点
    }
    /*前序遍历*/
    public  static  void  preOrder(Node root){
        if (root!=null){
            root.preOrder();
        }else {
            System.out.println("空赫夫曼数");
        }
    }
}

5.利用霍夫曼编码进行运算文件

1.结点类支持排序 实现比较器的接口

public class NodeCode implements Comparable<NodeCode>  {

    Byte data;//存放数据本身a：97  " ":32
    int weight;//字符出现的个数
    NodeCode left;//左节点
    NodeCode right;//右节点

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


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

    @Override
    public String toString() {
        return "NodeCode{" +
                "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();
        }
    }
}

2.赫夫曼编码对文件进行压缩和解压缩

public class HuffmanCodeTree {

    public static void main(String[] args) {
        //测试压缩文件
        String src = "F:\a.png";
        String dst = "F:\dst.zip";
        //zipFile(src,dst);
        //System.out.println("压缩文件成功");
        //测试解压文件
        String zip = "F:\dst.zip";
        String dstFile = "F:\a1.png";
        unZipFile(zip,dstFile);
        System.out.println("解压缩成功");








       String str = "i like like like java do you like a java";
      byte[] strBytes = str.getBytes();
      //分部测试
       //System.out.println(strBytes.length);
      /* List<NodeCode> list = getNodes(strBytes);
        System.out.println("list= "+list);
        *//*测试创建的二叉树*//*
        System.out.println("赫夫曼二叉树");
        NodeCode root = createHuffmanTree(list);
        preOrder(root);

        *//*测试生成对应的赫夫曼编码*//*
        Map<Byte, String> gethuffmanCode = gethuffmanCode(root);
        System.out.println("生成对应的赫夫曼编码: "+gethuffmanCode);

        //测试压缩
        byte[] zip = zip(strBytes, gethuffmanCode);
        System.out.println("zip =" + Arrays.toString(zip));*/
       /* byte[] huffmanZip = huffmanZip(strBytes);
        System.out.println("压缩后的结果 " +Arrays.toString(huffmanZip));
        System.out.println("长度为：" + huffmanZip.length);
        //发送zip数组；

        *//*解压缩*//*
        System.out.println("toBinaryString ="+ byteToBitSring(true,(byte)1));;

        *//**//*
        //赫夫曼字节数组对应的二进制字符串
       byte[] source = decode(huffmanCodes,huffmanZip);
        System.out.println("原来的字符串：" +  new String(source));*/



    }



     /*使用一个方法方便调用*/
    /**
     *
     * @description:TODO
     * @params:bytes：原始字符串对应的数组
     * @return: 
     * @author: 
     * @time: 2020/3/13 21:04
     */    
    public  static  byte[] huffmanZip(byte[] bytes){
        List<NodeCode> list = getNodes(bytes);
         //创建的赫夫曼树
        NodeCode root = createHuffmanTree(list);
        //生成对应的赫夫曼编码
        Map<Byte, String> gethuffmanCode = gethuffmanCode(root);
        byte[] huffmanZip = zip(bytes, gethuffmanCode);
        return huffmanZip;
    }





    /*为了方便调用,进行重载*/
    public static  Map<Byte,String> gethuffmanCode(NodeCode root){
         if (root==null){
             return null;
         }
         //处理root左子树
        gethuffmanCode(root.left,"0",stringBuilder);
         gethuffmanCode(root.right,"1",stringBuilder);
         return huffmanCodes;
    }





    private  static List<NodeCode> getNodes(byte[] bytes){
         //创建list
        ArrayList<NodeCode> nodeList = new ArrayList<>();
        Map<Byte, Integer> map = new HashMap<>();
        //存储byte出现的次数
        for (byte b : bytes) {
            Integer count =map.get(b);
            if (count == null){
                map.put(b,1);
            }else {
                map.put(b,count+1);
            }
        }
        //把每一个键值对转成NodeCode对象,放到list集合中
        for (Map.Entry<Byte,Integer> entry:map.entrySet()){
            nodeList.add(new NodeCode(entry.getKey(),entry.getValue()));
        }

        return nodeList;
    }


   /*创建赫夫曼树*/
    public  static  NodeCode createHuffmanTree(List<NodeCode> nodeList){
        //数组进行升序排序
        while (nodeList.size()>1){
            Collections.sort(nodeList);
            //System.out.println("list ="+list);
            //取出权值最小的二叉树
            NodeCode leftNo = nodeList.get(0);
           // 取出第二小的
            NodeCode rightNo = nodeList.get(1);
           // 构建新得二叉树
            /*根节点没有data只有权值*/
            NodeCode parent = new NodeCode(null,leftNo.weight+rightNo.weight);
            parent.left=leftNo;
            parent.right=rightNo;
            //删除list删除掉处理的二叉树
            nodeList.remove(leftNo);
            nodeList.remove(rightNo);
            //将父节点加入到list
            nodeList.add(parent);
           // System.out.println("第一次处理" +list);
        }
        return nodeList.get(0); //返回赫夫曼数的root节点
    }
    /*前序遍历*/
    public  static  void  preOrder(NodeCode root){
        if (root!=null){
            root.preOrder();
        }else {
            System.out.println("空赫夫曼数");
        }
    }

    /*生成赫夫曼编码表
      左节点：0
     右节点：1*/
    //生成对应的赫夫曼编码: {32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}

   static StringBuffer stringBuilder = new StringBuffer();//存储某个叶子节点的路径
   static Map<Byte,String> huffmanCodes = new HashMap<>();

   /**
    *
    * @description:生成赫夫曼编码,存储到Map
    * @params:1.根节点2.路径 左节点：0右节点：1   3.存储某个叶子节点的路径编码
    * @return:
    * @author: 
    * @time: 2020/3/13 19:49
    */
   public static  void gethuffmanCode(NodeCode node, String code, StringBuffer stringBuilder){
       StringBuffer stringBuffer2= new StringBuffer(stringBuilder);
       stringBuffer2.append(code);
       if (node!=null){
           if (node.data==null){//判断节点是否是叶子节点
               //递归处理
               //向左
               gethuffmanCode(node.left,"0",stringBuffer2);
               //向右
               gethuffmanCode(node.right,"1",stringBuffer2);
           }else {
               //找到叶子节点
               huffmanCodes.put(node.data,stringBuffer2.toString());
           }
       }
   }



   /*将一个字符对应的byte数组利用赫夫曼编码表，返回一个压缩编码的byte数组*/
    /**
     *
     * @description:TODO
     * @params:1.原始数组2.赫夫曼编码
     * @return:byte[]八位数组吧b[0] =10101000{补码}  ===>补码-1（10100111）反码
     * @author: 
     * @time: 2020/3/13 20:16
     */
    public  static  byte[] zip(byte[] bytes,Map<Byte,String> huffmanCodes){
         //利用赫夫曼编码表转成赫夫曼编码字符串
        StringBuffer buffer = new StringBuffer();
        for (byte b : bytes) {
           buffer.append(huffmanCodes.get(b));
        }
       /* System.out.println("测试buffer= "+buffer.toString());
        System.out.println(buffer.length());*/

        //统计字符串长度
        /*(buffer.length()+7)  /8 */
        int len;
        if (buffer.length()%8==0){
            len = buffer.length()/8;
        }else {
            len = buffer.length()/8+1;
        }
        //创建压缩后数组
        byte[] huffmanBys = new byte[len];
        int index = 0;//第几个byte
        for (int i = 0; i <buffer.length() ; i+=8) {//步长为8
            String strBy;
            if (i+8>buffer.length()){
                 strBy = buffer.substring(i);
            }else {
                 strBy = buffer.substring(i,i+8);
            }
            //将strBy转换成byte 放到by数组
            huffmanBys[index] = (byte)Integer.parseInt(strBy,2);
              index++;


        }
        return huffmanBys;
    }


       /*进行解压缩*/

    /**
     *
     * @description:将byte转成一个二进制字符串
     * @params:flag 真：需要不高位
     * @return:b对应二进制的字符串（按照补码返回）
     * @author: 
     * @time: 2020/3/13 21:20
     */
    public  static  String byteToBitSring(boolean flag , byte b) {
        //使用保存b
        int temp = b;
        /*如果是正数需要不高位*/
        if (flag) {
            temp |= 256;//按位与 1 0000 0000 |0000 0001 =>1 0000 0001
        }
        String str = Integer.toBinaryString(temp);//二进制的补码
        if (flag) {
            return str.substring(str.length() - 8);
        } else {
            return str;
        }
    }


    /*解码的方法*/
    /**
     *
     * @description:
     * @params:1.赫夫曼编码对照表 2.压缩的数组
     * @return:
     * @author: 
     * @time: 2020/3/13 21:46
     */
        public  static byte[] decode(Map<Byte,String> huffmanCodes , byte[]huffmanZip){
            //得到huffmanZip 对应的二进制的字符串101010000...
            StringBuilder builderString = new StringBuilder();

            //byte转换成二进制字符串

            /*如果是最后一个数不需要补高位*/
            for (int i = 0; i < huffmanZip.length; i++) {
                byte by = huffmanZip[i];
                boolean flag = (i==huffmanZip.length-1);
                 builderString.append(byteToBitSring(!flag, by));
            }
            System.out.println("赫夫曼字节数组对应的二进制字符串 ="+ builderString.toString());

            /*把字符串按照对应的赫夫曼编码进行编码*/
            Map<String,Byte> map =new HashMap<>();
            for (Map.Entry<Byte,String> entry : huffmanCodes.entrySet()){
                map.put(entry.getValue(),entry.getKey());
            }
            System.out.println("map =" +map);


            //创建集合存放byte

            List<Byte> list = new ArrayList<>();
            for (int i= 0; i < builderString.length();){
                int count = 1;//小的计数器
                boolean flag = true;
                Byte b = null;
                while (flag){
                    //递增取出key取出一个1或者0
                    String key = builderString.substring(i,i+count);//i不动count++直到匹配到一个字符
                    b = map.get(key);
                    if (b == null){
                        count++;
                    }else {
                        flag = false;
                    }
                }
                list.add(b);
                i += count;//让i移动到count；
            }
            //for循环结束后 list 存放为i like like like java do you like a java
            //将list 中的数据放到 byte[]并返回
            byte[] b = new byte[list.size()];
            for (int i = 0; i < b.length; i++) {
                b[i] = list.get(i);
            }
            return  b;
        }






        /*编写方法，将一个文件进行压缩*/
    /**
     *
     * @description:进行压缩文件
     * @params:1.传入压缩文件的全部路径2.压缩文件存放的位置
     * @return:
     * @author: 
     * @time: 2020/3/13 22:41
     */
    public  static void  zipFile(String srcFile,String dstFile){
        //创建输出流
        //创建文件的输入流
        FileInputStream is = null;
        FileOutputStream os = null;
        ObjectOutputStream oos = null;
        try {
             is = new FileInputStream(srcFile);
            //创建一个源文件大小相同的字节数组
            byte[]  b = new byte[is.available()];
            //读取文件
            is.read(b);
            //获取到文件进行压缩 得到字节数组
            byte[] huffmanBys = huffmanZip(b);
            //创建输出流
            os = new FileOutputStream(dstFile);
            //创建一个和文件输出流的objectOutStream
            oos = new ObjectOutputStream(os);
            //采用对象流将赫夫曼编码后的字节数组写入文件，可以有效的解压缩
            oos.writeObject(huffmanBys);
            /*将赫夫曼编码写入文件*/
            oos.writeObject(huffmanCodes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                oos.close();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }



    /*文件的解压操作的方法*/
    /**
     *
     * @description:TODO
     * @params:1.解压文件文字 2.保存的路径
     * @return: 
     * @author: 
     * @time: 2020/3/13 23:20
     */    
    public  static  void  unZipFile(String zipFile , String dsfFile){

        //创建文件的输入流
        InputStream is = null;
        //对象输入流
        ObjectInputStream ois = null;
        //文件的输出流
        OutputStream os = null;


        try {
            is = new FileInputStream(zipFile);
            //对象输入流
            ois =new ObjectInputStream(is);
            //读取数组
           byte[] huffmanBytes = (byte[]) ois.readObject();
           //读取赫夫曼编码表
            Map<Byte,String> huffmanCodes = (Map<Byte, String>) ois.readObject();
            //进行解码
            byte[] bytes = decode(huffmanCodes, huffmanBytes);
            //将bytes写入文件
            os = new FileOutputStream(dsfFile);
            os.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                os.close();
                ois.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
 
}