哈夫曼编码简单实现

最新推荐文章于 2022-06-25 17:22:01 发布
最新推荐文章于 2022-06-25 17:22:01 发布
阅读量815 收藏 3
点赞数
分类专栏： 算法与数据结构-java 文章标签： 霍夫曼树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40422192/article/details/123091520
版权

哈夫曼编码

基本介绍

赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法

赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。

赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间

赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码

i like like like java do you like a java       
// 共40个字符(包括空格)  

105 32 108 105 107 101 32 108 105 107 101 32 108 105 107 101 32 106 97 118 97 32 100 111 32 121 111 117 32 108 105 107 101 32 97 32 106 97 118 97  
//对应Ascii码

01101001 00100000 01101100 01101001 01101011 01100101 00100000 01101100 01101001 01101011 01100101 00100000 01101100 01101001 01101011 01100101 00100000 01101010 01100001 01110110 01100001 00100000 01100100 01101111 00100000 01111001 01101111 01110101 00100000 01101100 01101001 01101011 01100101 00100000 01100001 00100000 01101010 01100001 01110110 01100001 
//对应的二进制


按照二进制来传递信息，总的长度是  359   (包括空格)

image-20220107194902645

传输的 字符串
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 // 各个字符对应的个数

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

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

6 长度为 ： 133
说明:
原来长度是 359 , 压缩了 (359-133) / 359 = 62.9%
此编码满足前缀编码, 即字符的编码都不能是其他字符编码的前缀。不会造成匹配的多义性

赫夫曼编码是无损处理方案

思路

(1) Node { data (存放数据)， weight (权值)， left 和 right }
(2) 得到 “i like like like java do you like a java” 对应的 byte[] 数组
(3) 编写一个方法，将准备构建赫夫曼树的Node 节点放到 List , 形式 [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]…], 体现 d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 :9
(4) 可以通过List 创建对应的赫夫曼树

输入: i like like like java do you like a java

首先统计各个字符的数目，创建节点类和节点类对应的List集合

节点

创建HuffmanNode节点类继承Comparable，重写compareTo方法, 便于根据属性排序，重写tostring方法，便于直接输出。

  • data:字符
  • b: 该字符对应的字节
  • frequency: 该字符出现的频次
  • code ：该字符对应的哈夫曼编码
  • left
  • right
class HuffmanNode implements Comparable<HuffmanNode>{
    public HuffmanNode(char data, Integer frequency, HuffmanNode left, HuffmanNode right) {
        this.data = data;
        this.frequency = frequency;
        this.left = left;
        this.right = right;
    }

    public HuffmanNode(byte b,char data, Integer frequency) {
        this.b=b;
        this.data = data;
        this.frequency = frequency;
    }
    byte b;
    char data;
    Integer frequency;
    String code;
    HuffmanNode left;
    HuffmanNode right;

    @Override
    public int compareTo(HuffmanNode o) {
        if(this.frequency>o.frequency) return 1;
        else if (this.frequency<o.frequency) return -1;
        else return 0;
    }

    @Override
    public String toString() {
        return "HuffmanNode{" +
                "b=" + b +
                ", data=" + data +
                ", frequency=" + frequency +
                ", code=" + code +"}";
    }
}

创建方法统计各个字符数目和直接排序返回list

// 获得排序有序的节点list
    public static ArrayList<HuffmanNode> getList(byte[] bytes){
        ArrayList<HuffmanNode> list = new ArrayList<>();
        // 字符串进行扫描
        for (int i = 0; i < bytes.length; i++) {
            Boolean flag = true;
            // 查看列表里是否有该节点
            for (int j = 0; j < list.size(); j++) {
                if (bytes[i]==list.get(j).b){
                    list.get(j).frequency++;
                    flag = false;
                    break;
                }
            }
            // 没有添加该节点
            if(flag) list.add(new HuffmanNode(bytes[i],(char) bytes[i], 1));
        }
        // 对节点频数进行排序 从小到大
        Collections.sort(list);
        System.out.println();

        return list;
    }

根据List中的节点创建哈夫曼树并返回根节点

构建哈夫曼树, 每次选两个最小的节点，构成一个新的节点，放入list，排序，如此循环直到list只剩一个节点，也就是说只有一棵树了。

// 构建哈夫曼树，返回根节点
    public static HuffmanNode constructHuffmanTree(ArrayList<HuffmanNode> list, Integer length) {
        while (length>1){
            HuffmanNode leftNode = list.get(0);
            HuffmanNode rightNode = list.get(1);
            list.add(new HuffmanNode('-', leftNode.frequency+rightNode.frequency,leftNode,rightNode ));
            // 踩坑 删除两次第一个 而不是 0 1
            list.remove(0);
            list.remove(0);
            Collections.sort(list);
            length--;
        }

        return list.get(0);
    }

根据构建好的哈夫曼树，创建哈夫曼编码表，即获得每个字符对应的哈夫曼编码

// 获得每个字符对应的哈夫曼表
 public static HashMap<Byte,String> HaffumanCodeTable = new HashMap<>();
    public static void constructHuffmanCodeTable(HuffmanNode root){

        if(root.left==null&&root.right==null){
            root.code= code;
            HaffumanCodeTable.put(root.b,root.code);
        }
        if(root.left!=null){
            code=code+"0";
            constructHuffmanCodeTable(root.left);
            code=code.substring(0,code.length()-1);
        }
        if(root.right!=null){
            code=code+"1";
            constructHuffmanCodeTable(root.right);
            code=code.substring(0,code.length()-1);
        }
    }

对字节数组根据哈夫曼编码进行压缩

 /*
    *   功能：压缩
    *   输入: 源字符串转化为的bytes数组 byte[]  长度为40 需要40个字节来存储
    *   输出: 利用哈夫曼编码压缩后的byte[] 这里长度17
    *
    *   举例：
    *       字符串:i like like like java do you like a java
    *       对应的编码数据:10101000101111111100100010111111110010001011111111001001010011011100011100000110111010001111001010 00101111111100110001001010011011100
    *       此时该字符串长度133
    *       => byte[] haffumanCodeBytes => 每八位存进一个字节byte[i]
    *                   对于负数而言
    *                   haffumanCodeBytes[0] = 10101000 (补码)  =>  10101000- 1 = 10100111 (反码)  取反=> 11011000(原码)=-88
    * */
    private static byte[] zip(byte[] bytes) {
        // 1 利用哈夫曼编码表 将字节数组转化
        String code="";

        for (int i = 0; i < bytes.length; i++) {
            code=code+HaffumanCodeTable.get(bytes[i]);
        }


        int len;
        if(code.length()%8==0) len=code.length()/8;
        else len=code.length()/8+1;
        // 2 创建一个压缩后的byte数组
        byte[] zip=new byte[len];
        for (int i = 0; i < len; i++) {
            if(i*8+7>len){
                zip[i] = (byte) Integer.parseInt(code.substring(i*8,len),2);
                break;
            }
            zip[i] = (byte) Integer.parseInt(code.substring(i*8,i*8+7),2);
        }
        return zip;
    }

完整代码

package Tree;

import org.junit.Test;

import java.security.Principal;
import java.util.*;

import static java.util.Collections.*;

/**
 * @author yyq
 * @create 2022-01-07 19:57
 *
 * 哈夫曼编码
 * 问题: I love you.
 *       以最简单的方式对 I,l,o,v,e,y,u,.,空格 进行编码传输
 *       例如 I:01, l:11 ....
 *
 * 解决办法:
 *  1. 统计各个字符出现的次数
 *  2. 构建哈夫曼树
 *  3. 按照左 0 ，右 1 输出各个字符的编码
 *
 *  哈夫曼树节点  data,frequency,left,right
 *
 */



public class HuffmanCode {
    @Test
    public void testByte(){
        String strByte = "10101000";
        System.out.println((byte)Integer.parseInt(strByte, 2));


    }
    public static String code="";
    public static HashMap<Byte,String> HaffumanCodeTable = new HashMap<>();
    public static void main(String[] args) {
        String input = "i like like like java do you like a java";
        byte[] bytes = haffumanZip(input);
        System.out.println(Arrays.toString(bytes));
        String s = haffumanUnZip(bytes);



    }
    /*
    *  功能:对压缩后的字节数组还原成字符串
    * */

    public static String haffumanUnZip(byte[] zip){
        String code="";
        for (int i = 0; i < zip.length; i++) {
            code=code+zip.toString();
        }


        return null;
    }

    /*
    *  功能: 输入字符串进行压缩，返回压缩后的字节数组
    * */
    public static byte[] haffumanZip(String input){
        byte[] bytes = input.getBytes();
        System.out.println("压缩前字节数:"+bytes.length);
        ArrayList<HuffmanNode> list = new ArrayList<>();
        list = getList(bytes);

        // 构建哈夫曼树 每次挑选两个最小的节点 组成一个新的节点 在放入list 重复 直达节点长度为1
        Integer length = list.size();
        HuffmanNode root = constructHuffmanTree(list,length);

        // 生成哈夫曼树编码表
        constructHuffmanCodeTable(root);

        System.out.println("遍历哈夫曼树:");
        preOrder(root);

        System.out.println("哈夫曼表:");
        for(Byte key:HaffumanCodeTable.keySet()){
            System.out.println("key:"+key+" "+"Value:"+HaffumanCodeTable.get(key));
        }

        // 将字符串对应的byte数组通过哈夫曼编码表进行压缩，输出哈夫曼编码表压缩后的byte数组
        byte[] zip=zip(bytes);
        System.out.println("压缩后的字节数:"+zip.length);

        return zip;
    }

    private static void Action(byte[] bytes) {
        ArrayList<HuffmanNode> list = new ArrayList<>();
        list = getList(bytes);

        // 构建哈夫曼树 每次挑选两个最小的节点 组成一个新的节点 在放入list 重复 直达节点长度为1
        Integer length = list.size();
        HuffmanNode root = constructHuffmanTree(list,length);

        // 生成哈夫曼树编码表
        constructHuffmanCodeTable(root);

        System.out.println("遍历哈夫曼树:");
        preOrder(root);

        System.out.println("哈夫曼表:");
        for(Byte key:HaffumanCodeTable.keySet()){
            System.out.println("key:"+key+" "+"Value:"+HaffumanCodeTable.get(key));
        }

        // 将字符串对应的byte数组通过哈夫曼编码表进行压缩，输出哈夫曼编码表压缩后的byte数组
        byte[] zip=zip(bytes);
        System.out.println("压缩后的字节数:"+zip.length);



    }

    /*
    *   功能：压缩
    *   输入: 源字符串转化为的bytes数组 byte[]  长度为40 需要40个字节来存储
    *   输出: 利用哈夫曼编码压缩后的byte[] 这里长度17
    *
    *   举例：
    *       字符串:i like like like java do you like a java
    *       对应的编码数据:10101000101111111100100010111111110010001011111111001001010011011100011100000110111010001111001010 00101111111100110001001010011011100
    *       此时该字符串长度133
    *       => byte[] haffumanCodeBytes => 每八位存进一个字节byte[i]
    *                   对于负数而言
    *                   haffumanCodeBytes[0] = 10101000 (补码)  =>  10101000- 1 = 10100111 (反码)  取反=> 11011000(原码)=-88
    * */
    private static byte[] zip(byte[] bytes) {
        // 1 利用哈夫曼编码表 将字节数组转化
        String code="";

        for (int i = 0; i < bytes.length; i++) {
            code=code+HaffumanCodeTable.get(bytes[i]);
        }


        int len;
        if(code.length()%8==0) len=code.length()/8;
        else len=code.length()/8+1;
        // 2 创建一个压缩后的byte数组
        byte[] zip=new byte[len];
        for (int i = 0; i < len; i++) {
            if(i*8+7>len){
                zip[i] = (byte) Integer.parseInt(code.substring(i*8,len),2);
                break;
            }
            zip[i] = (byte) Integer.parseInt(code.substring(i*8,i*8+7),2);
        }
        return zip;
    }

    public static void preOrder(HuffmanNode node){
        if(node.left==null&&node.right==null)
        System.out.println(node);
        if(node.left!=null) preOrder(node.left);
        if(node.right!=null) preOrder(node.right);
    }

    // 获得每个字符对应的哈夫曼表
    public static void constructHuffmanCodeTable(HuffmanNode root){

        if(root.left==null&&root.right==null){
            root.code= code;
            HaffumanCodeTable.put(root.b,root.code);
        }
        if(root.left!=null){
            code=code+"0";
            constructHuffmanCodeTable(root.left);
            code=code.substring(0,code.length()-1);
        }
        if(root.right!=null){
            code=code+"1";
            constructHuffmanCodeTable(root.right);
            code=code.substring(0,code.length()-1);
        }
    }


    // 构建哈夫曼树，返回根节点
    public static HuffmanNode constructHuffmanTree(ArrayList<HuffmanNode> list, Integer length) {
        while (length>1){
            HuffmanNode leftNode = list.get(0);
            HuffmanNode rightNode = list.get(1);
            list.add(new HuffmanNode('-', leftNode.frequency+rightNode.frequency,leftNode,rightNode ));
            // 踩坑 删除两次第一个 而不是 0 1
            list.remove(0);
            list.remove(0);
            Collections.sort(list);
            length--;
        }

        return list.get(0);
    }

    // 获得排序有序的节点list
    public static ArrayList<HuffmanNode> getList(byte[] bytes){
        ArrayList<HuffmanNode> list = new ArrayList<>();
        // 字符串进行扫描
        for (int i = 0; i < bytes.length; i++) {
            Boolean flag = true;
            // 查看列表里是否有该节点
            for (int j = 0; j < list.size(); j++) {
                if (bytes[i]==list.get(j).b){
                    list.get(j).frequency++;
                    flag = false;
                    break;
                }
            }
            // 没有添加该节点
            if(flag) list.add(new HuffmanNode(bytes[i],(char) bytes[i], 1));
        }
        // 对节点频数进行排序 从小到大
        Collections.sort(list);
        System.out.println();

        return list;
    }
}


class HuffmanNode implements Comparable<HuffmanNode>{
    public HuffmanNode(char data, Integer frequency, HuffmanNode left, HuffmanNode right) {
        this.data = data;
        this.frequency = frequency;
        this.left = left;
        this.right = right;
    }

    public HuffmanNode(byte b,char data, Integer frequency) {
        this.b=b;
        this.data = data;
        this.frequency = frequency;
    }
    byte b;
    char data;
    Integer frequency;
    String code;
    HuffmanNode left;
    HuffmanNode right;

    @Override
    public int compareTo(HuffmanNode o) {
        if(this.frequency>o.frequency) return 1;
        else if (this.frequency<o.frequency) return -1;
        else return 0;
    }

    @Override
    public String toString() {
        return "HuffmanNode{" +
                "b=" + b +
                ", data=" + data +
                ", frequency=" + frequency +
                ", code=" + code +"}";
    }
}

zzu菜
关注
专栏目录
HUffman编码的简单实现
qq_40663787的博客
04-16 363
该题目答案，插入的时候可能因为顺序问题而导致错位 #include <stdio.h> #include <stdlib.h> typedef struct { int number; char value; struct Leaf *left, *right; struct Leaf *next; } Leaf; int fun...
【数据结构】哈夫曼树及哈夫曼编码实现（C语言）
热门推荐
weixin_51450101的博客
02-12 6万+
目录1. 哈夫曼树1.1 基本概念1.2 构造哈夫曼树1.3 哈夫曼树的类型定义1.4 哈夫曼树创建的算法实现2. 哈夫曼编码实现2.1 哈夫曼编码2.2 完整代码2.3 运行结果 1. 哈夫曼树 1.1 基本概念 路径：指从根结点到该结点的分支序列。 路径长度：指根结点到该结点所经过的分支数目。 结点的带权路径长度：从树根到某一结点的路径长度与该结点的权的乘积。 树的带权路径长度(WPL)：树中从根到所有叶子结点的各个带权路径长度之和。 哈夫曼树是由 n 个带权叶子结点构成的所有二叉树中带权路径长度最短的
哈夫曼编码实现
weixin_52632501的博客
06-25 1159
哈夫曼编码的实现
java实现赫夫曼编码
闵浮龙的博客
09-21 802
一、基本介绍 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%~90%之间 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码 二、原理剖析 通信领域中信息的处理方式 1-...
哈夫曼编码的实现
Mochaaa的博客
11-24 289
// Question.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "stdio.h" #include "stdlib.h" #define StringSize 30//输入最大字符串的大小 struct BiTreeNode//构造二叉树结构体 { char sign;//二叉树结点符号 int power;//二叉树结点的权值 ...
简单哈夫曼编码实例
10-02
在这个“简单哈夫曼编码实例”中，我们看到它对"a-e"这5个字母进行了编码，并且随机生成了包含0到30个这些字母的序列，然后进行了编码和解码的操作，同时提供了可视化界面以帮助理解过程。 哈夫曼编码的构建通常...
数据结构哈夫曼编码实验报告.doc
07-11
数据结构哈夫曼编码实验报告主要探讨了如何利用哈夫曼编码进行数据压缩与解压缩，以提高通信效率。哈夫曼编码是一种基于频率的前缀编码方法，它通过构建最优二叉树（哈夫曼树）来为不同的字符分配唯一的二进制编码，...
C++ 文件压缩 哈夫曼编码 游程编码.rar
05-24
本项目通过C++编程语言并结合QT库实现文件压缩功能，具体应用了两种经典压缩算法：哈夫曼编码和游程编码。接下来，我们将详细讨论这两种编码方式以及它们在实际中的应用。 首先，哈夫曼编码是一种基于频率的无损...
哈夫曼编码的实现（详细思路及c++一步一步代码实现）
One_castle的博客
11-20 1万+
哈夫曼编码的两个特殊性质： 1、哈夫曼编码是前缀编码。（问：啥是前缀编码？ 前缀编码就是在一个编码方案中，任何一个编码度不是其他任何编码的前缀（最左子串），那么这个编码就是前缀编码。） 2、哈夫曼编码是最优前缀编码。即对于包括n个字符的数据文件，分别以它们的出现次数为权值来构造哈夫曼树，则利用该树对应的哈夫曼编码对文件进行编码，能使该文件压缩后对应的二进制文件的长度最短。 哈夫曼编码的算法实现：...
huffman编码实现
阿鲲的专栏
07-16 1839
 大概思路:        1.计算目标文件A中的字符出现频率,从而确定权值        2.由字符权值构建huffman树,结构体数组作为此树的数据结构        3.由huffman树将目标文件A中所出现的每个字符编码        4.用字符编码将目标文件编码到新文件B        5.将编码文件B译码为文件C /*******************
haffman哈夫曼编码的实现
weixin_34256074的博客
04-14 228
&lt;span style="font-size:18px;"&gt;/* 1.在一棵二叉树中，我们定义从A节点到B节点所经过的分支序列为从A节点到B节点的路径； 定义从A节点到B节点所经过的分支个数为从A节点到B节点的路径长度。 定义从二叉树的根节点到二叉树中全部叶节点的路径长度之和为该二叉树的路径长度。 2.假设二叉树中的叶节点都带有权值，则能够把这个定义推广。设...
哈夫曼编码（贪心算法）报告.doc
12-26
哈夫曼编码是一种基于贪心策略的高效数据文件压缩编码方法，其核心在于通过构建最优前缀码来实现编码效率的最大化。在本实验报告中，我们将深入理解哈夫曼编码的工作原理、设计思想以及其实现过程。 1. 问题描述： ...
哈夫曼编码的算法实现
weixin_52634719的博客
10-28 1465
假设要得到G的编码，查7号结点的parent域的值，是8，再去查8的左孩子右孩子域的值，他是左孩子，标注0 8号结点的parent是10号，8是左孩子，记0......继续往上找， 有多少个结点做多少次，写成循环，有n个结点，i的值从1开始，i<=n，都需要求出他们的哈夫曼编码，每次都找当前节点的双亲，然后看他是左孩子还是右孩子，分出0和1，直到双亲的parent为0，就找到根结点，可以结束 while，用f表示parent的值，只要不为0，就要反复回溯到双亲 ...
哈夫曼编码的 C 语言实现
08-14
哈夫曼编码是一种无损的高效的压缩方法。对文本文件进行哈夫曼编码，使用计算信源熵打开一个文件进行概率计算，然后将输出的 submit.txt 文件用哈夫曼编码打开，之后就会对文本文件中出现的字符进行哈夫曼编码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值