赫夫曼树、赫夫曼编码

文章目录

  • 一、基本概念:
  • 二、创建赫夫曼树:
    • 1.思路:
    • 2.代码实现:
  • 三、赫夫曼编码:
    • 1.基本原理:
    • 2.案例:数据压缩
      • (1)创建赫夫曼树:
      • (2)生成赫夫曼编码和赫夫曼编码后的数据:
      • (3)解码:
      • (4)编码压缩文件:

一、基本概念:

赫夫曼树几个重要概念和举例说明:

  1. 路径和路径长度:在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为 1,则从根结点到第 L 层结点的路径长度为 L-1
  2. 结点的权及带权路径长度:若将树中结点赋给一个有着某种含义的数值,则这个数值称为该结点的权。结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积 。
  3. 树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和,记为 WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
  4. WPL 最小的就是赫夫曼树。
    赫夫曼树、赫夫曼编码_第1张图片

二、创建赫夫曼树:

1.思路:

给你一个数列 {13, 7, 8, 3, 29, 6, 1},要求转成一颗赫夫曼树。
构成赫夫曼树的步骤:

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

2.代码实现:

package huffmantree;
/**
 * 创建赫夫曼树
 */

import java.util.ArrayList;
import java.util.Collections;

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

    /**
     *
     * @param arr 需要创建成赫夫曼树的数组
     * @return 创建好后的赫夫曼树的root节点
     */
    public static Node createHuffmanTree(int[] arr){
        // 第一步为了操作方便
        // 1. 遍历 arr 数组
        // 2. 将 arr 的每个元素构成成一个 Node
        // 3. 将 Node 放入到 ArrayList 中
        ArrayList<Node> nodesList = new ArrayList<>();

        for(int value : arr){
            nodesList.add(new Node(value));
        }

//        System.out.println("node=" + nodesList);

        while (nodesList.size() > 1){

            Collections.sort(nodesList);

            Node leftNode = nodesList.get(0);
            Node rightNode = nodesList.get(1);

            Node parentNode = new Node(leftNode.value + rightNode.value);

            parentNode.left = leftNode;
            parentNode.right = rightNode;

            nodesList.remove(leftNode);
            nodesList.remove(rightNode);
            nodesList.add(parentNode);
        }

        return nodesList.get(0);
    }

    public static void preOrder(Node root){
        if (root != null){
            root.preOrder();
        }else{
            System.out.println("the tree is empty! can't list!");
        }
    }
}



// 创建结点类
// 为了让 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;
    }

    //使用前序遍历去测试输出的结果
    public void preOrder(){

        System.out.println(this);

        if (this.left != null){
            this.left.preOrder();
        }
        if (this.right != null){
            this.right.preOrder();
        }
    }
}

三、赫夫曼编码:

1.基本原理:

  1. 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式, 属于一种程序算法
  2. 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
  3. 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在 20%~90%之间
  4. 赫夫曼码是可变字长编码(VLC)的一种。Huffman 于 1952 年提出一种编码方法,称之为最佳编码
    赫夫曼树、赫夫曼编码_第3张图片
    赫夫曼树、赫夫曼编码_第4张图片
    此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性,赫夫曼编码是无损处理方案。
    注意:这个赫夫曼树根据排序方法不同,也可能不太一样,这样对应的赫夫曼编码也不完全一样,但是 wpl 是 一样的,都是最小的, 最后生成的赫夫曼编码的长度是一样。

2.案例:数据压缩

(1)创建赫夫曼树:

package huffmancode;

import java.util.*;

import static java.util.Collections.*;

/**
 * 赫夫曼编码
 */
public class HuffmanEncode {
    public static void main(String[] args) {

        String str = "i like like like java do you like a java";
        byte[] bytes = str.getBytes();
        List<Node> nodesList = getNode(bytes); //获得每个字符及其对应的权值
        System.out.println(nodesList); //查看每个字符及其所对应的权值

        Node nodeRoot = createHuffmanEncode(nodesList);//创建赫夫曼树,并返回根节点
        preOrder(nodeRoot); //遍历验证
    }

    /**
     * 就是要拿到所给字符串中的每个字符及其出现的次数,次数作为权值,进而构建赫夫曼树
     * @param bytes 接收字节数组
     * @return 返回的是list形式 【Ndoe[data= , weight= ]】
     */
    public static List<Node> getNode(byte[] bytes){
        ArrayList<Node> nodeList = new ArrayList<Node>();
        HashMap<Byte, Integer> map = new HashMap<>();
        for (byte b : bytes){
            Integer count = map.get(b);
            if (count == null){//表示b还没有被添加进来map中,进行添加
                map.put(b,1);
            }else{
                map.put(b,count+1);
            }
        }

        //遍历map,把每一个键值对转换成一个Node对象,并加入到nodeList
        for (Map.Entry<Byte,Integer> entry : map.entrySet()) {
            nodeList.add(new Node(entry.getKey(),entry.getValue()));
        }
        return nodeList;
    }

    //通过nodeList创建对应的赫夫曼树
    public static Node createHuffmanEncode(List<Node> list){

        while (list.size() > 1){
            Collections.sort(list);
            Node leftNode = list.get(0);
            Node rightNode = list.get(1);

            Node parentNode = new Node(null, leftNode.weight + rightNode.weight);

            parentNode.left = leftNode;
            parentNode.right = rightNode;

            list.remove(leftNode);
            list.remove(rightNode);
            list.add(parentNode);
        }
        return list.get(0);
    }

    public static void preOrder(Node root){
        if (root != null){
            root.preOrder();
        }else {
            System.out.println("tree is empty! can't list!");
        }
    }

}



class Node implements Comparable<Node>{
    int weight;
    Node left;
    Node right;
    Byte data; //存放数据(字符)本身

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

    @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.println(this);
        if (this.left != null){
            this.left.preOrder();
        }
        if (this.right != null){
            this.right.preOrder();
        }
    }
}

(2)生成赫夫曼编码和赫夫曼编码后的数据:

//**************************************************************
    //将赫夫曼编码存放在map中
    static Map<Byte, String> huffmanCodes = new HashMap<>();
    //生成赫夫曼编码表示,需要去拼接路径,使用StringBuilder 去存储某个叶子结点的路径
    static StringBuilder stringBuilder = new StringBuilder();

    /**
     * 将传入的node节点的所有叶子结点的赫夫曼编码得到,并放入到huffmanCodes集合中
     * @param node  传入节点
     * @param code 路径:向左子节点定义为0, 向右子节点定义为1
     * @param stringBuilder 用于拼接路径
     */
    public static void getCodes(Node node, String code, StringBuilder stringBuilder){
        StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
        stringBuilder2.append(code);//将code加入到stringBuilder2中
        if (node != null){
            //判断当前节点是叶子结点还是非叶子节点
            if (node.data == null){//表示是非叶子节点,递归处理
                getCodes(node.left,"0",stringBuilder2);
                getCodes(node.right,"1",stringBuilder2);
            }else {//说明是叶子结点,即找到了最后
                huffmanCodes.put(node.data,stringBuilder2.toString());
            }
        }
    }

    //重载getCodes方法,只传入根节点即可,然后将huffmanCodes集合返回
    public static Map<Byte,String> getCodes(Node nodeRoot){

        if (nodeRoot != null){
            getCodes(nodeRoot.left,"0",stringBuilder);
            getCodes(nodeRoot.right,"1",stringBuilder);
        }else{
            return null;
        }
        return huffmanCodes;
    }

//************************************************************
 //**********************************************************
    //将整个过程封装为一个方法
    public static byte[] huffmanEncode(String str){
        byte[] bytes = str.getBytes();
        List<Node> nodesList = getNode(bytes); //获得每个字符及其对应的权值
        Node nodeRoot = createHuffmanEncode(nodesList);//创建赫夫曼树,并返回根节点
        Map<Byte, String> mapCodes = getCodes(nodeRoot); //得到赫夫曼编码集
        byte[] huffmanEncodeBytes = encode(bytes, mapCodes); //返回赫夫曼编码的结果
        return huffmanEncodeBytes;
    }

    //**********************************************************

    /**
     * 进行编码, 返回字节数组
     * @param bytes
     * @param huffmanCodes
     * @return
     */
    public static byte[] encode(byte[] bytes, Map huffmanCodes){

        StringBuilder stringBuilder = new StringBuilder();
        for (byte b : bytes) {
            stringBuilder.append(huffmanCodes.get(b));
        }

        //将stringBuilder存储的编码字符串转换为每8位一组的byte数组
        int length = (stringBuilder.length() + 7) / 8;

        byte[]  huffmanCodeBytes = new byte[length];

        int index = 0;

        for (int i = 0; i < stringBuilder.length(); i+=8){
            String substring;

            if (i+8 > stringBuilder.length()){//表示不够8位的情况
                substring = stringBuilder.substring(i);
            }else {
                substring = stringBuilder.substring(i, i+8);
            }
            huffmanCodeBytes[index] = (byte) Integer.parseInt(substring,2);
            index++;
        }
        return huffmanCodeBytes;
    }

(3)解码:

解码过程存在一定问题,解码png图片会出现数组越界的错误。

 //*********************************************************
    //解码过程:

    public static String decode(Map<Byte,String> huffmanCodes, byte[] huffmanCodeBytes){

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < huffmanCodeBytes.length; i++){
            byte b = huffmanCodeBytes[i];
            //判断是不是最后一个字节
            boolean flag = ( i == huffmanCodeBytes.length -1);
            stringBuilder.append(byteToString(!flag,b));
        }

        //将赫夫曼编码表进行调换,因为是反向查询
        HashMap<String, Byte> map = new HashMap<>();
        for (Map.Entry<Byte,String> entry: huffmanCodes.entrySet()) {
            map.put(entry.getValue(),entry.getKey());
        }

        //创建集合,存放byte
        ArrayList<Byte> list = new ArrayList<>();
        for (int i = 0; i < stringBuilder.length();){
            int count = 1;
            boolean flag = true;
            Byte b = null;

            while (flag){
                String key = stringBuilder.substring(i, i + count);
                b = map.get(key);
                if (b == null){
                    count++;
                }else {
                    flag = false;
                }
            }
            list.add(b);
            i+=count;//移动i到count的位置
        }

        byte[] b = new byte[list.size()];
        for (int i = 0; i < b.length; i++){
            b[i] = list.get(i);
        }

        String decodeString = new String(b);
        return decodeString;
    }


    /**
     *将一个 byte 转成一个二进制的字符串。
     * @param flag 标志是否需要补高位如果是 true ,表示需要补高位,如果是 false 表示不补, 如果是最后一个 字节,无需补高位
     * @param b b 传入的 byte
     * @return 是该 b 对应的二进制的字符串,(注意是按补码返回)
     */
    public static String byteToString(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;
        }
    }

(4)编码压缩文件:

//**************************************************************
    //编写一个方法进行文件压缩

    /**
     *
     * @param srcFile 要压缩文件的路径
     * @param destFile 压缩文件存放的目录
     */
    public static void zipFile(String srcFile, String destFile)  {

        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        ObjectOutputStream os = null;
        try {
            inputStream = new FileInputStream(srcFile);
            //创建一个和源文件一样大小的byte[]
            byte [] b = new byte[inputStream.available()];

            inputStream.read(b);
            //对源文件进行压缩
            byte[] encodeBytes = huffmanEncode(b);
            //创建输出流,存放压缩文件
            outputStream = new FileOutputStream(destFile);
            //创建一个和输出流关联的ObjectOutputStream
            os = new ObjectOutputStream(outputStream);
            //以对象流的方式写入 编码结果(编码后的字节数组),为了以后恢复文件时使用
            os.writeObject(encodeBytes);
            //注意:一定要将赫夫曼编码 写入压缩文件,不然无法恢复
            os.writeObject(huffmanCodes);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null){
                try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
                }
            }
            if (outputStream != null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //文件解压缩

    /**
     *
     * @param zipFilePath 要解压缩文件的目录
     * @param destFilePath 解压缩完存放的目录
     */
    public static void unZipFile(String zipFilePath, String destFilePath) {

        FileInputStream is = null;
        ObjectInputStream ois = null;
        FileOutputStream os = null;
        try {
            is = new FileInputStream(zipFilePath);

            ois = new ObjectInputStream(is);

            //读取byte数组,编码后的huffmanBytes
            byte[] huffmanBytes = (byte[])ois.readObject();
            Map<Byte,String> huffmanCodes = (Map<Byte,String>)ois.readObject();

            //解码
            byte[] decodeBytes = decode(huffmanCodes, huffmanBytes);
            //将decodeBytes 写入到 目标文件中
            os = new FileOutputStream(destFilePath);
            os.write(decodeBytes);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

你可能感兴趣的:(Java笔记)