数据结构与算法（十七）

其他 2019-05-08 16:17:37 阅读次数: 0
版权声明：版权由我个人所有，未经允许不得用于除学习外的其他用途，望周知。 https://blog.csdn.net/weixin_44515563/article/details/89301630

赫夫曼树编码

在这里插入图片描述

创建Node类

package com.bjsxt.TestHuffmanCode;

public class Node implements Comparable<Node>{
    Byte data;
    int weight;
    Node left;
    Node right;
    public Node(Byte data,int weight){
        this.data=data;
        this.weight=weight;
    }

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

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

实现编码之前的代码

package com.bjsxt.TestHuffmanCode;

import java.util.*;

public class TestHuffmanCode {
    public static void main(String[] args){
        String msg = "can you can a can as a can canner can a can.";
        byte[] bytes = msg.getBytes();
        //进行赫夫曼编码
        byte[] b = huffmanZIP(bytes);
    }
    /**
     * 进行赫夫曼编码压缩方法
     * @param bytes
     * @return
     */
    private static byte[] huffmanZIP(byte[] bytes){
        //先统计每一个byte出现的次数，并放入一个集合中
        List<Node> nodes = getNodes(bytes);
        //创建一棵赫夫曼树
        Node tree = createHuffmanTree(nodes);
        System.out.println(tree);
        System.out.println(tree.left);
        System.out.println(tree.right);
        //创建一个赫夫曼编码表
        //编码
        return null;
    }
    /**
     * 创建赫夫曼树
     * @param nodes
     * @return
     */
    private static Node createHuffmanTree(List<Node> nodes) {
        while(nodes.size()>1){
            //排序
            Collections.sort(nodes);
            //取出两个权值最低的二叉树
            Node left = nodes.get(nodes.size()-1);
            Node right = nodes.get(nodes.size()-2);
            //创建一棵新的二叉树
            Node parent = new Node(null,left.weight+right.weight);
            //把之前取出来的两棵二叉树设置为新创建的二叉树的子树
            parent.left=left;
            parent.right=right;
            //把前面取出来的两棵二叉树删除
            nodes.remove(left);
            nodes.remove(right);
            //把新建的二叉树放入集合中
            nodes.add(parent);
        }
        return nodes.get(0);
    }
    /**
     * 把byte数组转为node集合
     * @param bytes
     * @return
     */
    private static List<Node> getNodes(byte[] bytes){
        List<Node> nodes = new ArrayList<>();
        //存储每一个byte出现了多少次
        Map<Byte,Integer> counts = new HashMap<>();
        //统计每一个byte出现的次数
        for(byte b:bytes){
            Integer count = counts.get(b);
            if(count==null){
                counts.put(b,1);
            }else {
                counts.put(b,count+1);
            }
        }
//        System.out.println(counts);
        //把每一个键值对转为一个node对象
        for(Map.Entry<Byte,Integer> entry:counts.entrySet()){
            nodes.add(new Node(entry.getKey(),entry.getValue()));
        }
        return nodes;
    }
}

利用赫夫曼编码压缩代码

package com.bjsxt.TestHuffmanCode;

import java.util.*;

public class TestHuffmanCode {
    public static void main(String[] args){
        String msg = "can you can a can as a can canner can a can.";
        byte[] bytes = msg.getBytes();
        //进行赫夫曼编码压缩
        byte[] b = huffmanZIP(bytes);
        //使用赫夫曼编码进行解码
//        byte[] newBytes = decode(huffCodes,b);
        System.out.println(bytes.length);
        System.out.println(b.length);
    }
    /**
     * 进行赫夫曼编码压缩方法
     * @param bytes
     * @return
     */
    private static byte[] huffmanZIP(byte[] bytes){
        //先统计每一个byte出现的次数，并放入一个集合中
        List<Node> nodes = getNodes(bytes);
        //创建一棵赫夫曼树
        Node tree = createHuffmanTree(nodes);
//        System.out.println(tree);
//        System.out.println(tree.left);
//        System.out.println(tree.right);
        //创建一个赫夫曼编码表
        Map<Byte,String> huffCodes = getCodes(tree);
        System.out.println(huffCodes);
        //编码
        byte[] b = zip(bytes,huffCodes);

        return b;
    }

    /**
     * 进行赫夫曼编码
     * @param bytes
     * @param huffCodes
     * @return
     */
    private static byte[] zip(byte[] bytes, Map<Byte, String> huffCodes) {
        StringBuilder sb = new StringBuilder();
        //把需要压缩的byte数组处理成一个二进制的字符串
        for(byte b:bytes){
            sb.append(huffCodes.get(b));
        }
//        System.out.println(sb.toString());
        //定义长度
        int len;
        if(sb.length()%8==0){
            len=sb.length()/8;
        }else {
            len=sb.length()/8+1;
        }

        //用于存储压缩后的byte
        byte[] by = new byte[len];
        //记录新的byte的位置
        int index=0;
        for(int i=0;i<sb.length();i+=8){
            String strByte;
            if(i+8>sb.length()){
                strByte = sb.substring(i);
            }else {
                strByte = sb.substring(i, i + 8);
            }
//            System.out.println(strByte);
            byte byt = (byte)Integer.parseInt(strByte,2);
//            System.out.println(strByte+":"+byt);
            by[index]=byt;
            index++;
        }

     return by;
    }

    //用于临时存储路径
    static StringBuilder sb = new StringBuilder();
    //用于存储赫夫曼编码
    static Map<Byte,String> huffCodes = new HashMap<>();
    /**
     * 根据赫夫曼树获取赫夫曼编码
     * @param tree
     * @return
     */
    private static Map<Byte, String> getCodes(Node tree) {
        if(tree==null){
            return null;
        }
        getCodes(tree.left,"0",sb);
        getCodes(tree.right,"1",sb);
        return huffCodes;
    }

    private static void getCodes(Node node, String code, StringBuilder sb) {
        StringBuilder sb2 = new StringBuilder(sb);
        sb2.append(code);
        if(node.data==null){
            getCodes(node.left,"0",sb2);
            getCodes(node.right,"1",sb2);
        }else{
            huffCodes.put(node.data,sb2.toString());
        }
    }

    /**
     * 创建赫夫曼树
     * @param nodes
     * @return
     */
    private static Node createHuffmanTree(List<Node> nodes) {
        while(nodes.size()>1){
            //排序
            Collections.sort(nodes);
            //取出两个权值最低的二叉树
            Node left = nodes.get(nodes.size()-1);
            Node right = nodes.get(nodes.size()-2);
            //创建一棵新的二叉树
            Node parent = new Node(null,left.weight+right.weight);
            //把之前取出来的两棵二叉树设置为新创建的二叉树的子树
            parent.left=left;
            parent.right=right;
            //把前面取出来的两棵二叉树删除
            nodes.remove(left);
            nodes.remove(right);
            //把新建的二叉树放入集合中
            nodes.add(parent);
        }
        return nodes.get(0);
    }
    /**
     * 把byte数组转为node集合
     * @param bytes
     * @return
     */
    private static List<Node> getNodes(byte[] bytes){
        List<Node> nodes = new ArrayList<>();
        //存储每一个byte出现了多少次
        Map<Byte,Integer> counts = new HashMap<>();
        //统计每一个byte出现的次数
        for(byte b:bytes){
            Integer count = counts.get(b);
            if(count==null){
                counts.put(b,1);
            }else {
                counts.put(b,count+1);
            }
        }
//        System.out.println(counts);
        //把每一个键值对转为一个node对象
        for(Map.Entry<Byte,Integer> entry:counts.entrySet()){
            nodes.add(new Node(entry.getKey(),entry.getValue()));
        }
        return nodes;
    }
}

赫夫曼完整代码（包括解压代码）

package com.bjsxt.TestHuffmanCode;

import java.util.*;

public class TestHuffmanCode {
    public static void main(String[] args){
        String msg = "can you can a can as a can canner can a can.";
        byte[] bytes = msg.getBytes();
        //进行赫夫曼编码压缩
        byte[] b = huffmanZIP(bytes);
        //使用赫夫曼编码进行解码
        byte[] newBytes = decode(huffCodes,b);
//        System.out.println(bytes.length);
//        System.out.println(b.length);
        System.out.println("原字符串转成的二进制字符串"+Arrays.toString(bytes));
        System.out.println(("新字符串转成的二进制字符串"+Arrays.toString(newBytes)));
        System.out.println("原字符串"+msg.toString());
        System.out.println("新字符串"+new String(newBytes));
    }

    /**
     * 使用指定的赫夫曼编码表进行解码
     * @param huffCodes
     * @param bytes
     * @return
     */
    private static byte[] decode(Map<Byte, String> huffCodes, byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        //把byte数组转为一个二进制的字符串
        for(int i=0;i<bytes.length;i++){
            byte b = bytes[i];
            //是否是最后一个
            boolean flag = (i==bytes.length-1);
            sb.append(byteToBitStr(!flag,b));
//            String s = Integer.toBinaryString(b);
//            System.out.println(s);
        }
//        System.out.println(sb.toString());
        //把字符串按照指定的赫夫曼编码进行解码
        //把赫夫曼编码的键值对进行调换
        Map<String,Byte> map=new HashMap<>();
        for(Map.Entry<Byte,String> entry:huffCodes.entrySet()){
            map.put(entry.getValue(),entry.getKey());
        }
        //创建一个集合，用于存byte
        List<Byte> list = new ArrayList<>();
        //处理字符串
        for(int i=0;i<sb.length();){
            int count = 1;
            boolean flag = true;
            Byte b = null;
            //截取出一个byte
            while(flag){
                String key = sb.substring(i,i+count);
                b=map.get(key);
                if(b==null){
                    count++;
                }else{
                    flag=false;
                }
            }
            list.add(b);
            i+=count;
        }
        //把集合转为数组
        byte[] b = new byte[list.size()];
        for(int i=0;i<b.length;i++){
            b[i]=list.get(i);
        }
//        System.out.println(list);
        return b;
    }
    private static String byteToBitStr(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;
        }
    }

    /**
     * 进行赫夫曼编码压缩方法
     * @param bytes
     * @return
     */
    private static byte[] huffmanZIP(byte[] bytes){
        //先统计每一个byte出现的次数，并放入一个集合中
        List<Node> nodes = getNodes(bytes);
        //创建一棵赫夫曼树
        Node tree = createHuffmanTree(nodes);
//        System.out.println(tree);
//        System.out.println(tree.left);
//        System.out.println(tree.right);
        //创建一个赫夫曼编码表
        Map<Byte,String> huffCodes = getCodes(tree);
//        System.out.println(huffCodes);
        //编码
        byte[] b = zip(bytes,huffCodes);

        return b;
    }

    /**
     * 进行赫夫曼编码
     * @param bytes
     * @param huffCodes
     * @return
     */
    private static byte[] zip(byte[] bytes, Map<Byte, String> huffCodes) {
        StringBuilder sb = new StringBuilder();
        //把需要压缩的byte数组处理成一个二进制的字符串
        for(byte b:bytes){
            sb.append(huffCodes.get(b));
        }
//        System.out.println(sb.toString());
        //定义长度
        int len;
        if(sb.length()%8==0){
            len=sb.length()/8;
        }else {
            len=sb.length()/8+1;
        }

        //用于存储压缩后的byte
        byte[] by = new byte[len];
        //记录新的byte的位置
        int index=0;
        for(int i=0;i<sb.length();i+=8){
            String strByte;
            if(i+8>sb.length()){
                strByte = sb.substring(i);
            }else {
                strByte = sb.substring(i, i + 8);
            }
//            System.out.println(strByte);
            byte byt = (byte)Integer.parseInt(strByte,2);
//            System.out.println(strByte+":"+byt);
            by[index]=byt;
            index++;
        }

     return by;
    }

    //用于临时存储路径
    static StringBuilder sb = new StringBuilder();
    //用于存储赫夫曼编码
    static Map<Byte,String> huffCodes = new HashMap<>();
    /**
     * 根据赫夫曼树获取赫夫曼编码
     * @param tree
     * @return
     */
    private static Map<Byte, String> getCodes(Node tree) {
        if(tree==null){
            return null;
        }
        getCodes(tree.left,"0",sb);
        getCodes(tree.right,"1",sb);
        return huffCodes;
    }

    private static void getCodes(Node node, String code, StringBuilder sb) {
        StringBuilder sb2 = new StringBuilder(sb);
        sb2.append(code);
        if(node.data==null){
            getCodes(node.left,"0",sb2);
            getCodes(node.right,"1",sb2);
        }else{
            huffCodes.put(node.data,sb2.toString());
        }
    }

    /**
     * 创建赫夫曼树
     * @param nodes
     * @return
     */
    private static Node createHuffmanTree(List<Node> nodes) {
        while(nodes.size()>1){
            //排序
            Collections.sort(nodes);
            //取出两个权值最低的二叉树
            Node left = nodes.get(nodes.size()-1);
            Node right = nodes.get(nodes.size()-2);
            //创建一棵新的二叉树
            Node parent = new Node(null,left.weight+right.weight);
            //把之前取出来的两棵二叉树设置为新创建的二叉树的子树
            parent.left=left;
            parent.right=right;
            //把前面取出来的两棵二叉树删除
            nodes.remove(left);
            nodes.remove(right);
            //把新建的二叉树放入集合中
            nodes.add(parent);
        }
        return nodes.get(0);
    }
    /**
     * 把byte数组转为node集合
     * @param bytes
     * @return
     */
    private static List<Node> getNodes(byte[] bytes){
        List<Node> nodes = new ArrayList<>();
        //存储每一个byte出现了多少次
        Map<Byte,Integer> counts = new HashMap<>();
        //统计每一个byte出现的次数
        for(byte b:bytes){
            Integer count = counts.get(b);
            if(count==null){
                counts.put(b,1);
            }else {
                counts.put(b,count+1);
            }
        }
//        System.out.println(counts);
        //把每一个键值对转为一个node对象
        for(Map.Entry<Byte,Integer> entry:counts.entrySet()){
            nodes.add(new Node(entry.getKey(),entry.getValue()));
        }
        return nodes;
    }
}

猜你喜欢

转载自blog.csdn.net/weixin_44515563/article/details/89301630
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022