Java实现赫夫曼编码、解码、文件压缩和解压

最新推荐文章于 2024-06-20 09:05:23 发布
最新推荐文章于 2024-06-20 09:05:23 发布
阅读量3.6k 收藏 7
点赞数 9
分类专栏： Java数据结构与算法 文章标签： java 算法 数据结构 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44381387/article/details/120696770
版权
本文详细介绍了赫夫曼编码的概念、原理及其实现过程，包括如何构建赫夫曼树、生成赫夫曼编码以及应用在数据压缩中的步骤。通过一个具体的字符串示例展示了如何将文本压缩为赫夫曼编码，并给出了压缩前后长度的对比，强调了赫夫曼编码在无损压缩中的应用。同时，提供了Java代码实现文件的赫夫曼压缩和解压缩，以及注意事项，例如压缩已压缩文件可能效果不明显等。
摘要由CSDN通过智能技术生成

11.3 赫夫曼编码

11.3.1 基本介绍

  1. 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法。
  2. 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
  3. 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在 20%～90%之间
  4. 赫夫曼码是可变字长编码(VLC)的一种。Huffman 于 1952 年提出一种编码方法，称之为最佳编码

11.3.2 原理刨析

通信领域中信息的处理方式-----赫夫曼编码
步骤如下：
传输的字符串 i like like like java do you like a java

  1. i like like like java do you like a java
  2. d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9（空格:9） // 各个字符对应的个数
  3. 按照上面字符出现的次数构建一颗赫夫曼树, 次数作为权值
    步骤：

构成赫夫曼树的步骤：

  1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树

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

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

  4. 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树。
    在这里插入图片描述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（空格:01）

  5. 按照上面的赫夫曼编码，我们的"i like like like java do you like a java" 字符串对应的编码为 (注
    意这里我们使用的无损压缩)
    1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110 通过赫夫曼编码处理 长度为 133

  6. 长度为 ： 133
    说明:如果不压缩转换成二进制的长度是 359 , 压缩了 (359-133) / 359 = 62.9%

此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性赫夫曼编码是无损处理方案

注意事项
注意, 这个赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是 wpl 是一样的，都是最小的, 最后生成的赫夫曼编码的长度是一样，比如: 如果我们让每次生成的新的二叉树总是排在权值相同的二叉树的最后一个，则生成的二叉树为:

在这里插入图片描述

11.3.3 最佳实践-数据压缩(创建赫夫曼树)

将给出的一段文本，比如 “i like like like java do you like a java” ， 根据前面的讲的赫夫曼编码原理，对其进行数据 压 缩 处 理 ， 形 式 如:
“1010100110111101111010011011110111101001101111011110100001100001110011001111000011001111000100100100110111101111011100100001100001110”

步骤 1：根据赫夫曼编码压缩数据的原理，需要创建 “i like like like java do you like a java” 对应的赫夫曼树。
思路：前面已经分析过了。
代码：（为了防止混乱，赫夫曼编码代码和下面的解码代码放在一起）

11.3.4 最佳实践-数据压缩(生成赫夫曼编码和赫夫曼编码后的数据)

我们已经生成了 赫夫曼树, 下面我们继续完成任务

  1. 生成赫夫曼树对应的赫夫曼编码 , 如下表: =01 a=100 d=11000 u=11001 e=1110 v=11011 i=101 y=11010 j=0010 k=1111 l=000 o=0011
  2. 使用赫夫曼编码来生成赫夫曼编码数据 ,即按照上面的赫夫曼编码，将"i like like like java do you like a java" 字符串生成对应的编码数据, 形式如:下：1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100
  3. 思路：前面已经分析过了。

赫夫曼编码和解码代码实现

赫夫曼编码实现文件的压缩和解压代码也在里面

import java.io.*;
import java.util.*;

/**
 * @author zk
 * @version 1.0.0
 * @ClassName HuffmanCode.java
 * @Description TODO huffman编码
 * @createTime 2021年09月27日 12:52:00
 */
public class HuffmanCode {
    public static void main(String[] args) {
        /*String str = "i like like like java do you like a java";
        byte[] bytes = str.getBytes();
        byte[] huffmanBytes = huffmanZip(bytes);
        System.out.println("huffman编码后："+Arrays.toString(huffmanBytes));
        byte[] decode = decode(huffmanCode, huffmanBytes);
        System.out.println("huffman解码后："+new String(decode));*/

        /*List<Node> nodes = huffmanTreeList(bytes);
        Node huffmanTreeRoot = createHuffmanTree(nodes);
        preOrder(huffmanTreeRoot);
        Map<Byte, String> huffmanCode = getHuffmanCode(huffmanTreeRoot);
        huffmanCode.forEach((k, v)->{
            System.out.print(k+"--"+v+"\t");
        });
        System.out.println();
        byte[] zip = zip(bytes, huffmanCode);
        System.out.println(Arrays.toString(zip));*/

        // 测试Huffman文件压缩
//        String srcFile = "E:\\11.jpg";
//        String dstFile = "E:\\11.zip";
//        zipFile(srcFile,dstFile);
        // 测试Huffman文件解压
        String srcFile = "E:\\11.zip";
        String dstFile = "E:\\22.jpg";
        unZip(srcFile,dstFile);
    }



    // TODO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓中间代码为huffman文件压缩和解码的相关方法↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
    /**
     *
     * @param srcFile 你传入的希望压缩的文件的全路径
     * @param dstFile 我们压缩后将压缩文件放到哪个目录
     */
    public static void zipFile(String srcFile, String dstFile){
        InputStream is = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;
        try {
            is = new FileInputStream(srcFile);
            byte[] b = new byte[is.available()];
            is.read(b);
            os = new FileOutputStream(dstFile);
            oos = new ObjectOutputStream(os);
            // huffman压缩
            //把 赫夫曼编码后的字节数组写入压缩文件
            byte[] huffmanBytes = huffmanZip(b);
            oos.writeObject(huffmanBytes);
            //这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用
            //注意一定要把赫夫曼编码 写入压缩文
            oos.writeObject(huffmanCode);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * @param zipFile 准备解压的文件
     * @param dstFile 将文件解压到哪个路径
     **/
    public static void unZip(String zipFile,String dstFile){
        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> huffmanCode = (Map<Byte, String>) ois.readObject();
            byte[] bytes = decode(huffmanCode, huffmanBytes);
            os = new FileOutputStream(dstFile);
            os.write(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }










    // TODO ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑中间代码为huffman文件压缩和解码的相关方法↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑





    // TODO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓中间代码为huffman解码的相关方法↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
    //编写一个方法，完成对压缩数据的解码
    /**
     *
     * @param huffmanCodes 赫夫曼编码表 map
     * @param huffmanBytes 赫夫曼编码得到的字节数组
     * @return 就是原来的字符串对应的数组
     */
    private static byte[] decode(Map<Byte,String> huffmanCodes, byte[] huffmanBytes){
        // 获得huffmanBytes 数组对应的二进制字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < huffmanBytes.length; i++) {
            byte b = huffmanBytes[i];
            boolean flag = (i==huffmanBytes.length-1);
            String string = byteToBitString(b, !flag);
            stringBuilder.append(string);
        }

        // 把huffmanCodes 反过来  接下来进行解码
        HashMap<String, Byte> map = new HashMap<>();
        for (Map.Entry<Byte, String> byteStringEntry : huffmanCodes.entrySet()) {
            map.put(byteStringEntry.getValue(),byteStringEntry.getKey());
        }

        // 把解码的数据先存放到list
        ArrayList<Byte> list = new ArrayList<>();
        for (int i = 0; i < stringBuilder.length();) {
            boolean flag = true;
            int count = 1;
            Byte b = null;
            while (flag){
                // 截取字符串范围 start(包括)  end(不包括)
                String str = stringBuilder.substring(i, i+count);
                b = map.get(str);
                if (b==null){
                    count++;
                }else {
                    list.add(b);
                    flag = false;
                }
            }
            i += count;
        }

        // 把list集合的数据放到 byte数组
        byte[] bytes = new byte[list.size()];
        for (int i = 0; i < list.size(); i++) {
            bytes[i] = list.get(i);
        }
        return bytes;
    }

    /**
     * 将一个 byte 转成一个二进制的字符串
     * @param b 传入的 byte
     * @param flag 标志是否需要补高位如果是 true ，表示需要补高位，如果是 false 表示不补, 如果是最后一个
    字节，无需补高位
     * @return 是该 b 对应的二进制的字符串，（注意是按补码返回）
     */
    public static String byteToBitString(byte b,boolean flag){
        int temp = b;
        if (flag){
            temp |= 256;  //按位与 256 1 0000 0000 | 0000 0001 => 1 0000 000
        }
        String str = Integer.toBinaryString(temp);
        if (flag){
            return str.substring(str.length()-8);
        }else {
            return str;
        }
    }


    // TODO↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑中间代码为huffman解码的相关方法↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑


    /**
     * @Author zk
     * @Description //TODO
     * @Date 2021/9/27 15:52
     * @param bytes 待编码的数组
     * @return byte[] 使用huffman编码后的数组
     **/

    public static byte[] huffmanZip(byte[] bytes){
        List<Node> nodes = huffmanTreeList(bytes);
        Node huffmanTreeRoot = createHuffmanTree(nodes);
        Map<Byte, String> huffmanCode = getHuffmanCode(huffmanTreeRoot);
        return zip(bytes, huffmanCode);
    }
    /**
     * @Author zk
     * @Description //TODO
     * @Date 2021/9/27 15:31
     * @param bytes 待压缩的数组
     * @param huffmanCode 哈夫曼编码
     * @return void
     **/

    public static byte[] zip(byte[] bytes,Map<Byte, String> huffmanCode){
        // 1.利用huffmanCode 将bytes 转换成huffmanCode对应的字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (byte b : bytes) {
            stringBuilder.append(huffmanCode.get(b));
        }

        //统计返回byte[] huffmanCodeBytes 长度
        int len = 0;
        if (stringBuilder.length() % 8==0){
            len = stringBuilder.length() / 8;
        }else {
            len = stringBuilder.length() / 8 + 1;
        }
        // 创建存储压缩后的bytes[]
        byte[] huffmanCodeBytes = new byte[len];
        int index = 0;
        for (int i = 0; i < stringBuilder.length(); i+=8) {
            String substring;
            if (i+8>stringBuilder.length()){
                substring = stringBuilder.substring(i);
            }else {
                substring = stringBuilder.substring(i,i+8);
            }

            huffmanCodeBytes[index] = (byte) Integer.parseInt(substring,2);
            index++;
        }
        return huffmanCodeBytes;
    }

    // 为了方便调用  重载getHuffmanCode()方法
    public static Map<Byte,String> getHuffmanCode(Node root){
        if (root !=null){
            getHuffmanCode(root,"",stringBuilder);
        }else {
            System.out.println("root node is null");
        }
        return huffmanCode;
    }

    /**
     * 功能：将传入的 node 结点的所有叶子结点的赫夫曼编码得到，并放入到 huffmanCodes 集合
     *
     * @param node          传入结点
     * @param code          路径： 左子结点是 0, 右子结点 1
     * @param stringBuilder 用于拼接路径
     */
    // 储存生成的哈夫曼编码
    static Map<Byte,String> huffmanCode = new HashMap<>();
    // 生成哈夫曼编码过程中拼接字符串
    static StringBuilder stringBuilder = new StringBuilder();

    public static void getHuffmanCode(Node node, String code, StringBuilder stringBuilder) {
        StringBuilder stringBuilder1 = new StringBuilder(stringBuilder);
        stringBuilder1.append(code);
        if (node != null) {
            if (node.data == null) {  //非叶子节点
                //递归处理
                //向左递归
                if (node.left!=null){
                    getHuffmanCode(node.left,"0",stringBuilder1);
                }
                //向右递归
                if (node.right!=null){
                    getHuffmanCode(node.right,"1",stringBuilder1);
                }

            } else { // 叶子节点
                huffmanCode.put(node.data,stringBuilder1.toString());
            }
        }
    }

    // 前序遍历huffmanTree
    public static void preOrder(Node root) {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("root is null");
        }
    }

    public static Node createHuffmanTree(List<Node> nodeList) {

        while (nodeList.size() > 1) {
            Collections.sort(nodeList);
            Node leftNode = nodeList.get(0);
            Node rightNode = nodeList.get(1);
            Node parent = new Node(null, leftNode.weight + rightNode.weight);
            parent.left = leftNode;
            parent.right = rightNode;
            nodeList.add(parent);
            nodeList.remove(leftNode);
            nodeList.remove(rightNode);
        }
        return nodeList.get(0);
    }

    public static List<Node> huffmanTreeList(byte[] bytes) {
        List<Node> nodes = new ArrayList<>();
        Map<Byte, Integer> map = new HashMap<>();
        for (byte b : bytes) {
            Integer count = map.get(b);
            if (count == null) {
                map.put(b, 1);
            } else {
                map.put(b, count + 1);
            }
        }

        Set<Map.Entry<Byte, Integer>> entries = map.entrySet();
        for (Map.Entry<Byte, Integer> entry : entries) {
            nodes.add(new Node(entry.getKey(), entry.getValue()));
        }
        return nodes;
    }
}


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 int compareTo(Node o) {
        return this.weight - o.weight;
    }

    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{" +
                "data=" + data +
                ", weight=" + weight +
                '}';
    }


}

11.3.9 赫夫曼编码压缩文件注意事项

  1. 如果文件本身就是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化, 比如视频,ppt 等等文件【举例：压缩一个ppt】
  2. 赫夫曼编码是按字节来处理的，因此可以处理所有的文件(二进制文件、文本文件) [举例压一个.xml 文件]
  3. 如果一个文件中的内容，重复的数据不多，压缩效果也不会很明显
小凯子丶
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【赫夫曼编码】实现文件中数据的加解密与压缩
weixin_43232564的博客
05-14 3996
背景知识：二叉树的应用、赫夫曼树。 目的要求：掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 实验内容：实现文件中数据的加解密与压缩：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别；对加密文件进行解密，比较原始文件和解码文件的内容是否一致。
利用赫夫曼编码对文件进行压缩和解压（Java实现）
weixin_44015485的博客
07-21 302
至于赫夫曼编码是什么我就不多介绍了，直接讲解如何压缩和解压吧 1.压缩文件 我写的压缩文件主要分为一下几步 1.将文件转换成字节数组，并转换成Node节点存入List中 2.创建赫夫曼树 3.生成赫夫曼编码 4.根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组 /** * 压缩方法 * @param bytes 原始字符串得字节数组 * @return 根据生成得赫夫曼编码，压缩得到压缩后得赫夫曼编码字节数组 */ private static byte[] huffmanZip(
数据结构哈夫曼编码实验报告.doc
07-11
数据结构实验报告 ―― 实验五 简单哈夫曼编/译码的设计与实现 本实验的目的是通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在 实际问题中的应用。此实验可以作为综合实验，阶段性实验时可以选择其中的几个功能 来设计和实现。 一、【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本 。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数 据进行译码，此实验即设计这样的一个简单编/码系统。系统应该具有如下的几个功能： 1、接收原始数据。 从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nod edata.dat中。 2、编码。 利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat中读入），对文件中的正 文进行编码，然后将结果存入文件code.dat中。 3、译码。利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件tex tfile.dat中。 4、打印编码规则。 即字符与编码的一一对应关系。 二、【数据结构设计】 1、构造哈夫曼树时使用静态链表作为哈夫曼树的
（C++）Huffman编码 加密压缩并解码文件
谁取了我的ID：gz007的博客
05-13 2200
Huffman编码 加密压缩并解码文件Huffman编码实验目的实验内容实验说明主要数据类型与变量插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Huffman编码 实验目的 掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 实验内容 实现文件中数据的加解密与压缩：将硬盘上的一个文本
java 霍夫曼解码
最新发布
csdn_aspnet的专栏
06-20 1万+
在给定的 C++ 实现中，时间复杂度主要由使用优先级队列创建 Huffman 树决定，这需要 O(n log n) 时间。霍夫曼编码算法的时间复杂度为O(n log n)，其中n为输入字符串的字符个数。下面的代码将一个字符串作为输入，对其进行编码，并将其保存在变量编码字符串中。4、如果在遍历过程中遇到叶节点，我们会打印该特定叶节点的字符，然后再次从步骤 1 开始继续迭代编码数据。由此可见，编码后的数据量是比较大的，上面的方法也可以帮我们确定N的值，也就是编码后数据的长度。要解码编码数据，我们需要霍夫曼树。
数据结构实验二（赫夫曼编码及应用）
心之所向
07-14 1991
在实验中，我们首先定义了赫夫曼树（HuffmanTree）和赫夫曼编码表（HuffmanCode）的数据结构。赫夫曼树用于构建字符频率的最优二叉树，而赫夫曼编码表用于存储每个字符对应的赫夫曼编码。这些数据结构为后续的加密、解密和比对操作提供了基础支持。首先，我们实现了文件读写模块，用于读取和写入文件数据。通过使用标准库函数，我们能够打开源文件和目标文件，并进行数据的读取和写入操作。这使得我们能够在程序中处理文件数据。
哈夫曼编码位图压缩代码c语言,基于哈夫曼编码实现文件压缩与解压缩
weixin_29728529的博客
05-19 784
基于哈夫曼编码实现文件压缩是在学习数据结构(严蔚敏版)书中哈夫曼树及其应用后对书中伪代码的实现和完善，采用哈夫曼静态编码的方式，通过对数据进行两遍扫描，第一次统计出现的字符频次，进而构造哈夫曼树，第二遍扫描数据根据得到的哈夫曼树对数据进行编码。对于其中的加密编码只是简单的将用户输入的密码用特殊的标识位拼接成字符串加入需要统计的数据，可以在拥有哈夫曼编码表以及加密后的文本情况下进行解密哈夫曼树给定n...
霍夫曼编码_文件压缩及解压（Java实现)
qq_41203254的博客
03-03 830
1级标题
java实现赫夫曼树编码和解码byte[]
12-21
总结，Java实现的赫夫曼树编码和解码`byte[]`是一个利用数据频率实现数据压缩的过程，它涉及到二叉树的构建，编码映射以及解码还原。这种编码方式在节省存储空间的同时，也需要考虑计算效率和适用场景。
霍夫曼编码实现文件压缩和解压
05-06
利用实现的最小堆实现霍夫曼编码，利用霍夫曼编码实现文件压缩和解压。 包括最小堆，霍夫曼编码，解压，压缩四个部分，代码功能完善，对ASCII码英文文本有1.8压缩率。使用C++编写。（现只能压缩文本文件）
用赫夫曼编码完成文件压缩--16页.pdf
09-05
赫夫曼编码是一种高效的数据压缩方法，主要用于文本文件的压缩，尤其在通信和存储领域有广泛应用。该编码方法基于赫夫曼树（也称为最优二叉树），通过为出现频率较低的字符分配较短的编码，而为出现频率较高的字符...
Huffman.zip
08-19
运用赫夫曼（Huffman）树和赫夫曼编码的基本思想，实现文件中数据的加解密与压缩。
赫夫曼编码压缩也解压文件
08-27
"Huffman_coding_finish" 文件可能是C语言实现的赫夫曼编码压缩和解压程序的源代码，包括了赫夫曼树的构建、编码生成、压缩和解压缩的算法。 在这个课程设计中，学生不仅可以学习到赫夫曼编码的理论，还能实际动手...
赫夫曼编码的Java实现
03-16
NULL 博文链接：https://hunnuxiaobo.iteye.com/blog/397792
数据结构：哈夫曼编码
qq_51518416的博客
06-12 235
void decoding() { sum_bit_decoding = 0; //路径coding char coding_file_name[100]; strcpy(coding_file_name, file_out); strcat(coding_file_name, "coding.txt"); //路径encoding char encoding_file_name[100]; strcpy(encoding_file_name,...
数据结构第二次实验-赫夫曼编码及其应用
qq_49383677的博客
06-08 2050
一、实验目的 1．目的：掌握赫夫曼（Huffman）树和赫夫曼编码的基本思想和应用。 2．任务：实现文件中数据的加解密与压缩。 二、实验内容及要求 1、任务描述 实验内容：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别； 对加密文件进行解密，比较原始文件和解码文件的内容是否一致。 输入和输出： （1）输入：硬盘上给定的原始文件及文件路径。 （2）输出： ◆ 硬盘上的加密文件及文件路径； ◆ 硬盘上的解码文件及文件路径； ◆ 原始文件和解码文件的比对结果。 实验要求： ◆ 提取.
哈夫曼编码对字符串的压缩与解压缩（Java）
Mzh1996的博客
08-05 2647
最近学习韩顺平老师主讲的“图解java 数据结构与算法”的哈夫曼编码这一章节时，在编码实现上遇到了些许问题，本文主要记述一下问题及自己的解决方案，如有更优解还请指点
22. 赫夫曼编码，以及赫夫曼编码的实现，赫夫曼编码的文件压缩与解压
乖乖虎学java
03-11 521
23
赫夫曼编码解码C语言实现
小小本科生
06-14 1720
赫夫曼编码解码 一、实验目的 掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 二、 实验内容及要求 任务描述 实现文件中数据的加解密与压缩：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件 的大小差别；对加密文件进行解密，比较原始文件和解码文件的内容是否一致。 程序源代码： DS.h #include <stdio.h> #include <string.h> #include <stdlib.h> #include <ctype.h> HFTr
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小凯子丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值