霍夫曼编码_文件压缩及解压（Java实现)

一、明确功能

1、基础功能

将一串字符串"i like like like java do you like a java"利用霍夫曼编码原理进行压缩，并解压（即还原）。

2、扩展功能

进一步引入文件读写操作，对给定的图片或者文本文件，对其进行压缩，并将压缩的文件，重新恢复成原来的文件。

二、算法原理

1、霍夫曼树基本介绍

• 霍夫曼树定义
  给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，即霍夫曼树(Huffman Tree)。霍夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
• 路径和路径长度：
  在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。
• 结点的权及带权路径长度
  若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度（weighted path length）为：从根结点到该结点之间的路径长度与该结点的权的乘积。如下图三种建树方式，图二实现的带权路径长度最小，wpl为59.
  

2、霍夫曼树的创建思路

1、从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树；
2、取出根节点权值最小的两颗二叉树
3、组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和 ；
3、再将这颗新的二叉树，以根节点的权值大小再次排序，不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树。

霍夫曼树的代码实现

要求：将数列 {13, 7, 8, 3, 29, 6, 1}转成一颗赫夫曼树。注意：因为数组是无法直接操作的，因此要先创建树的结点类Node。

package chuchu.huffmantree;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class HuffManTreeDemo {
   
    public static void main(String[] args) {
   
        int[] arr={
   13,7,8,3,29,6,1};
        Node root=huffmantree(arr);
        Preorder(root);//前序遍历
    }

    //将数组传进去，返回来的是搭建好的树的根节点
    public static Node huffmantree(int[] arr){
   
        List<Node> nodes=new ArrayList<Node>();
        for(int item:arr){
   
            Node cur=new Node(item);
            nodes.add(cur);
        }

        while(nodes.size()>1){
   
            Collections.sort(nodes);//先排序
            //System.out.println("nodes"+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;
			//删除旧节点，将新生成的节点加入
            nodes.remove(leftnode);
            nodes.remove(rightnode);
            nodes.add(parent);
        }
        return nodes.get(0);//返回整棵树的根节点

    }
    public static void Preorder(Node root){
   
        if(root!=null){
   
            root.preOreder();
        }else{
   
            System.out.println("空");
        }

    }
}

//为了让Node对象支持排序Collections集合排序，让Node实现Comparable接口
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;
        //若表示从大到小排序
        //return -(this.value-o.value);
    }

    //二叉树的前序遍历
    public void preOreder(){
   
        System.out.println(this);//先输出当前节点
        if(this.left!=null){
   
            this.left.preOreder();//处理左子节点
        }
        if(this.right!=null){
   
            this.right.preOreder();//处理右子节点
        }

    }
}

3、霍夫曼编码

1. i like like like java do you like a java // 共40个字符(包括空格)
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. 按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值；
   
4. 根据赫夫曼树，给各个字符规定编码 ，向左的路径为0，向右的路径为1，编码如下:
   o: 1000 u: 10010 d: 100110 y: 100111 i: 101 a : 110 k: 1110 e: 1111
   j: 0000 v: 0001 l: 001 （空格）: 01
5. 按照上面的赫夫曼编码，我们的"i like like like java do you like a java" 字符串对应的编码为：
   1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110
   长度为 ： 133
   说明:原来长度是359 , 压缩了 (359-133) / 359 = 62.9%
   注意：此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性。

三、实现思路

1、实现对字符串的压缩编码

1、首先将字符串转为字节数组byte[]，这一步很好实现，用getBytes()方法即可。

String content="i like like like java do you like a java";
byte[] contentbytes=content.getBytes();

2、为实现霍夫曼编码，需要创建霍夫曼树。
(1)首先创建节点类：treeNode:

//构建节点类
class treeNode implements Comparable<treeNode>{
   
    Byte data;//存放的数据
    int value;//节点权值
    treeNode left;//左子节点
    treeNode right;//右子节点

    public treeNode(Byte data, int value) {
   
        this.data = data;
        this.value = value;
    }

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

    @Override
    public int compareTo(treeNode o) {
   
        //表示从小到大排序
        return this.value-o.value;
        //若表示从大到小排序
        //return -(this.value-o.value);
    }

    //前序遍历
    public void preOreder(){
   
        System.out.println(this);
        if(this.left!=null){
   
            this.left.preOreder();
        }
        if(this.right!=null){
   
            this.right.preOreder();
        }

    }
}

(2)遍历byte[]数组，统计每个字符出现的次数，并将“字符->次数”作为键值（data->weight）转化为treeNode类型，并存入nodes集合中。

public static List<treeNode> getList(byte[] contentbytes){
   
        ArrayList<treeNode> nodes=new ArrayList<treeNode>();
        //遍历bytes，统计每个byte出现的次数
        Map<Byte,Integer>counts=new HashMap<>();
        for(byte item:contentbytes){
   
            Integer count=counts.get(item);//寻找Map中item对应的value
            if(count==null){
   //说明这个count还不存在
                counts.put(item,1);
            }else {
   
                counts.put(item,count+1);
            }
        }
        //把每对键值转化为treeNode并存入nodes集合中
        //遍历Map
        for(Map.Entry<Byte,Integer>entry:counts.entrySet()){
   
            nodes.add(new treeNode(entry.getKey(),entry.getValue()));
        }
        return nodes;

    }

（3）构建赫夫曼树，原理上面已经讲过，这里有必要注意的是：非叶子节点是没有存放数据的，即data为null。

//构建霍夫曼树
    public static treeNode createhuffmantree(List<treeNode> nodes){
   
        while(nodes.size()>1){
   
            Collections.sort(nodes);
            treeNode leftNode=nodes.get(0);
            treeNode rightNode=nodes.get(1);
            treeNode parentNode=new treeNode(null,leftNode.value+rightNode.value);//非叶子节点只有权重，没有data
            parentNode.left=leftNode;
            parentNode.right=rightNode;
            nodes.remove(0);
            nodes.remove(0);
            nodes.add(parentNode);
        }
        return nodes.get(0);
    }

（4）将霍夫曼树转为霍夫曼编码，并将每个字符和它对应的霍夫曼编码存入Map中。

/*
 * 功能描述:将霍夫曼树转为霍夫曼编码并存入Map中
 * @param: node:传入节点
 * @param: curcode:当前节点的路径
 * @param: stringBuilder：用于字符串拼接
*  @return void
        */
    public static void getCodes(treeNode node,String curcode,StringBuilder stringBuilder){
   
        StringBuilder stringBuilder2=new StringBuilder(stringBuilder);
        stringBuilder2.append(curcode);
        if(node!=null){
   //如果node为空则不处理
            //判断是否为叶子节点
            if(node.data==null){
   //说明为非叶子节点
                getCodes(node.left,"0",stringBuilder2);
                getCodes(node.right,"1",stringBuilder2);
            }else{
   //是叶子节点
                huffmancodes.put(node.data,stringBuilder2.toString());
            }
        }
    }

（5）遍历字符串对应的byte[]数组（即第1步得到的contentbytes），根据第4步得到的霍夫曼编码Map,查询到每个byte对应的霍夫曼编码，将其进行拼接，最终生成一长串二进制霍夫曼编码，但这串二进制编码并不能直接用于传输，要将其转换为byte[]形式。

 /*
     * 功能描述:将字符串对应的byte[]数组，根据霍夫曼编码Map,生成一长串二进制霍夫曼编码，并将其转换为byte[]
     * @param: bytes  即contentbytes
     * @param: huffmanCodes 每个字符的byte对应的映射表
     * @return byte[] 拼接好的二进制霍夫曼编码转化为byte[]
            */
    public static byte