Huffman编码

最新推荐文章于 2024-04-20 11:37:23 发布
最新推荐文章于 2024-04-20 11:37:23 发布
阅读量145 收藏
点赞数
分类专栏： 数据编码 文章标签： huffman tree 二叉树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36438744/article/details/104848315
版权

Huffman编码

编码原理

  1. huffman二叉树构造过程

    1. 由给定的m{1…m}个权值，构造m课二叉树,每个二叉树只有一个根节点,它的权值为m(i)
    2. 选取根结点的权值最小的两个结点，将他们作为左右子树，构造成一棵新的二叉树，它的根结点的权值置为其左、右子树根结点权值之和
    3. 重复执行步骤（2）最后得到Huffman树

  2. Huffman二叉树的性质

    1. 为满二叉树(不存在度为1的结点) : 设叶子结点的个数为 n 则 Huffman树的总

      结点个数 = 2 * n -1

    2. 二叉树与字符编码对应关系

      1. 结点 对应 文档中出现的所有字符
      2. 叶子结点路径:从根据结点到叶子结点的路径,对应每个字符的编码
      3. 叶子结点路径长度:从根结点到叶子结点的长度, 对应每个编码的 二进制位数
      4. 叶子结点带权路径长度:编码后该篇文档中某个字符的数据量
      5. 树的带权路径长度:编码后,改变文档总的数据量

    3. 由于从根节点到叶子结点的各个路径不同,故Huffman编码 是一种变长前缀编码

  3. 如下是 文本 abbcccdddd的Huffman树

    1. 图
      在这里插入图片描述

    2. 对应编码图

      abcd
      编码100101110
      路径长度3321
      结点的权值1234
      结点的带权路径长度3664
      整个Huffman树的带权路径长度(bit位) ,wpl19

编码步骤

编码 --以文本 "abbcccdddd"为例

  1. 统计字符个数

    abcd
    1234

  2. 依据字符出现的次数构建优先级队列

  3. 依据优先级队列构建Huffman树

  4. 遍历Huffman表 构建Huffman编码对照表

    abcd
    100101110

  5. 依据编码对照表,重新对字符串编码

    abbcccdddd -> 1001011011111110000

  6. 将编码写入文件

    1. 写入表头
      1. 表头部分 = 编码对照表长度 + 编码对照表
    2. 写入数据

解码

  1. 读入表头部分,形成Huffman编码
  2. 将Huffman编码表 转换成 Huffman树 便于解析数据部分
  3. 读入数据,依据Huffman树转换字符

数据量分析

  1. 原数据量(bit数) = 10* 8 = 80 ;
  2. 编码后数据量 = wpl值 = 19 ;
  3. 理论压缩比率 = 19 / 80 ;
  4. 实际压缩比率 = (19 + 表头部分数据) / 80

C语言实现

  1. 编码

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct __tag_binary_node
{
    struct __tag_binary_node *right;
    struct __tag_binary_node *left;
    struct __tag_binary_node *next;
    int data;
    char c;
} binary_node;

typedef struct __tag_huffmanTable
{
    int val;
    int start;
} huffmanTable;

//[字符 - 字符出现次数]  对照表
int charTable[255] = {0};
// [字符 - 对应bit编码表 ]
huffmanTable *htable[255] = {0};

binary_node *new_binary_node(int data, char c)
{
    binary_node *node = (binary_node *)malloc(sizeof(binary_node));
    node->data = data;
    node->right = NULL;
    node->left = NULL;
    node->next = NULL;
    node->c = c;
    return node;
}

void priority_enqueue(binary_node **head, binary_node *node)
{
    if (head == NULL)
    {
        return;
    }

    binary_node *tmpnode = *head;

    if (*head != NULL)
    {
        if (node->data - tmpnode->data > 0)
        {
            while (tmpnode->next && node->data - tmpnode->next->data > 0)
            {
                tmpnode = tmpnode->next;
            };
            node->next = tmpnode->next;
            tmpnode->next = node;
        }
        else
        {
            node->next = tmpnode;
            *head = node;
        }
    }
    else
    {
        *head = node;
    }
}

binary_node *priority_dequeue(binary_node **head)
{
    if (*head == NULL)
    {
        return NULL;
    }
    binary_node *node = *head;
    *head = (*head)->next;
    return node;
}

void countChar(FILE *f)
{
    char buf[1024];
    int len;
    while ((len = fread(buf, sizeof(char), sizeof(buf), f)) > 0)
    {
        for (size_t i = 0; i < len; i++)
        {
            charTable[buf[i]]++;
        }
    }
}
//构造Huffman树
void buildPriorityQueue(binary_node **head)
{
    for (size_t i = 0; i < sizeof(charTable) / sizeof(int); i++)
    {
        if (charTable[i])
        {
            binary_node *node = new_binary_node(charTable[i], i);
            priority_enqueue(head, node);
        }
    }
}

//根据 优先级队列转换 成 huaffmantree
binary_node *buildHuffman(binary_node **head)
{
    binary_node *tmpnode1 = NULL;
    binary_node *tmpnode2 = NULL;
    while (*head)
    {
        tmpnode1 = priority_dequeue(head);
        tmpnode2 = priority_dequeue(head);
        if (tmpnode2 != NULL)
        {
            binary_node *node = new_binary_node(tmpnode1->data + tmpnode2->data, 0);
            node->left = tmpnode1;
            node->right = tmpnode2;
            priority_enqueue(head, node);
        }
    }
    return tmpnode1;
}

//按习惯, 字节都是从高位 开始写入,所以 逆序转换
int reverseByte(int sum, int start)
{
    int count = 0;
    for (size_t i = 0; i < start; i++)
    {
        count += ((sum >> i) & 1) * (1 << start - i - 1);
    }
    return count;
}
// 根据 Huffman树 构建Huffman编码对照表, sum计算每次走过路径的值, i表示路径长度, wpl = 所有叶子结点的权值 * 路径长度
int tohuffManTable(binary_node *node, int i, int sum)
{
    int wpl = 0;
    if (node->left != NULL)
    {
        wpl += tohuffManTable(node->left, i + 1, sum);
    }

    if (node->right != NULL)
    {
        wpl += tohuffManTable(node->right, i + 1, sum + (1 << i));
    }

    if (node->left == NULL && node->right == NULL)
    {

        htable[node->c] = (huffmanTable *)malloc(sizeof(huffmanTable));
        htable[node->c]->val = reverseByte(sum, i);
        htable[node->c]->start = i;
        wpl += node->data * i;
    }
    return wpl;
}
/* 
    编码文件的格式  = 表头 + 编码后的数据
    表头 =  出现字符的个数 (int)  +  wpl(int)  +  {字符:Huffman编码对照表}
*/
void encodeFile(FILE *src, int wpl, FILE *f)
{
    int size_metadata = 0;
    int size_data = 0;
    int size_real = 0;
    //插入表头
    //统计字符的个数
    int tablesize = 0;
    for (size_t i = 0; i < 255; i++)
    {
        if (htable[i])
        {
            tablesize++;
        }
    }
    //出现字符的个数 (int)
    fwrite(&tablesize, sizeof(int), 1, f);
    size_metadata += sizeof(int);
    //wpl
    fwrite(&wpl, sizeof(int), 1, f);
    size_metadata += sizeof(int);

    for (size_t i = 0; i < 255; i++)
    {
        if (htable[i])
        {
            //该字符
            fwrite(&i, sizeof(char), 1, f);
            size_metadata += sizeof(char);
            //该字符对应的Huffman编码
            fwrite(htable[i], sizeof(huffmanTable), 1, f);
            size_metadata += sizeof(huffmanTable);
        }
    }

    unsigned int sum = 0, k = 0;
    char buf[1024];

    // 初始化
    int len = fread(buf, sizeof(char), sizeof(buf), src);
    size_real += len;
    huffmanTable *t = htable[buf[0]];
    int start = t->start;
    int toLen = sizeof(int) * 8;

    while (1)
    {
        if (toLen == 0)
        {
            //如果 toLen,32 位 都已填充完则,写入sum到文件, 并重置 sum,toLen
            toLen = sizeof(int) * 8;
            fwrite(&sum, sizeof(sum), 1, f);
            size_data += sizeof(int);
            sum = 0;
        }

        if (start == 0)
        {
            //若某个字符 已写完,则K++, 更换下一个字符
            ++k;
            //若buf缓冲区已读完,则继续从文件中读下一个
            if (k == len)
            {
                //若文件已读完则跳出循环,while循环唯一出口
                if ((len = fread(buf, sizeof(char), sizeof(buf), src)) <= 0)
                {
                    break;
                }
                //缓冲区读入之后,重置k
                k = 0;
                size_real += len;
            }
            //重置 t,start
            t = htable[buf[k]];
            start = t->start;
        }
        /*
            32位无符号整型中对应的权重: 1 << toLen - 1
            判断编码 在start位的 0或1: (t->val >> start - 1) & 1 
        */
        sum += (1 << toLen - 1) * ((t->val >> start - 1) & 1);
        toLen--;
        start--;
    }
    // 退出后 还剩最后一个没写完
    fwrite(&sum, sizeof(sum), 1, f);
    size_data += sizeof(int);

    printf("元数据:%d,编码数据:%d,真实数据:%d,理论压缩率%.2f,实际压缩率%.2f\n", size_metadata, size_data, size_real, size_data * 1.0 / size_real, (size_data + size_metadata) * 1.0 / size_real);
}

int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("usage: %s srcFilePath  destFilePath", argv[0]);
        return 1;
    }
    FILE *newfile = fopen(argv[1], "r");
    if (newfile == NULL)
    {
        printf("源文件不存在,或者目标路径不可用\n");
        return 1;
    }
    FILE *f = fopen(argv[2], "wb");
    // 统计字符出现个数
    countChar(newfile);
    rewind(newfile);

    //构建优先级队列
    binary_node *head = NULL;
    buildPriorityQueue(&head);

    //构建Huffman树
    binary_node *rootNode = buildHuffman(&head);

    //遍历Huffman树形成 编码表,并求出 wpl(weighted path length),即对应 编码后的 bit数
    int wpl = tohuffManTable(rootNode, 0, 0);
    //求出remain
    int remain = (sizeof(int) * 8 - wpl % (sizeof(int) * 8));

    //编码文件
    encodeFile(newfile, wpl, f);

    return 0;
}

  2. 解码

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct __tag_binary_node
{
    struct __tag_binary_node *right;
    struct __tag_binary_node *left;
    struct __tag_binary_node *next;
    int data;
    char c;
} binary_node;

typedef struct __tag_huffmanTable
{
    int val;
    int start;
} huffmanTable;

binary_node *new_binary_node(int data, char c)
{
    binary_node *node = (binary_node *)malloc(sizeof(binary_node));
    node->data = data;
    node->right = NULL;
    node->left = NULL;
    node->next = NULL;
    node->c = c;
    return node;
}



void decodeTable()
{
    FILE *f = fopen("C:\\Users\\Administrator\\Documents\\Tencent Files\\1259103745\\FileRecv\\b.txt", "rb");

    fseek(f, 0, SEEK_END);
    long size = ftell(f);
    fseek(f, 0, SEEK_SET);

    //读 tableSize
    int tableSize = 0;
    fread(&tableSize, sizeof(int), 1, f);
    size -= sizeof(int);
    //读 wpl
    int wpl = 0;
    fread(&wpl, sizeof(int), 1, f);
    size -= sizeof(int);
    int remain = 32 - wpl % 32;
    printf("wpl=%d,remain=%d", wpl, remain);
    char ch = 0;
    //读Huffmantable,并生成Huffman树
    binary_node *head = new_binary_node(0, 0), *tmpNode = head;
    int start;
    for (size_t i = 0; i < tableSize; i++)
    {
        huffmanTable *t = (huffmanTable *)malloc(sizeof(huffmanTable));
        fread(&ch, sizeof(char), 1, f);
        size -= sizeof(char);
        fread(t, sizeof(huffmanTable), 1, f);
        size -= sizeof(huffmanTable);
        start = t->start;
        while (--start >= 0)
        {
            if (t->val & (1 << start))
            {
                if (tmpNode->right == NULL)
                {
                    tmpNode->right = new_binary_node(0, 0);
                    if (start == 0)
                    {
                        tmpNode->right->c = ch;
                    }
                }
                tmpNode = tmpNode->right;
            }
            else
            {
                if (tmpNode->left == NULL)
                {
                    tmpNode->left = new_binary_node(0, 0);
                    if (start == 0)
                    {
                        tmpNode->left->c = ch;
                    }
                }
                tmpNode = tmpNode->left;
            }
        }
        tmpNode = head;
    }
    unsigned int read;
    long alreadyRead = 0;
    int toLen = 0;
    do
    {
        if (toLen == 0)
        {
            toLen = sizeof(int) * 8;
            fread(&read, sizeof(int), 1, f);
            alreadyRead += sizeof(int);
            if (alreadyRead == size)
            {
                toLen -= remain;
                read >>= remain;
            }
        }
        if (tmpNode->right == NULL && tmpNode->left == NULL)
        {
            putchar(tmpNode->c);
            tmpNode = head;
        }
        if (read & (1 << toLen - 1))
        {
            tmpNode = tmpNode->right;
        }
        else
        {
            tmpNode = tmpNode->left;
        }
        toLen--;
    } while (alreadyRead < size || toLen != 0);
    putchar(tmpNode->c);
}

int main(int argc, char const *argv[])
{

    //解码文字
    decodeTable();
    return 0;
}

写在最后

  1. 编码的难点在于 位与 字符间 的切换
  2. 目前只支持 ASCII编码的字符
  3. 写入表头部分格式 是本人自定义的
  4. 本篇博客的目的供自己学习参考用,如有错误 欢迎批评指正
weisanju
关注
专栏目录
霍夫曼编码c++
12-13 764
/* * huffman.c * 霍夫曼编码代码 * Created on: Dec 12, 2016 * Author: xuenhappy * * sample: * ============ input file: ============ t 2 h 1 i 2 s 2 _ 7 a 4 n 2 e 4 x 1 m 2 p 1 l 1 o 1 f 3
huffman(赫夫曼编码)之C/C++实现
chandzwx的专栏
11-05 1079
有点儿兴奋，有点儿紧张，这是我人生发的第一篇正式的blog，在进入正文之前，请容许我说一点儿序言，之所以发这一blog文章，一来是想记录下自己一天做了些什么，学了些什么，所谓：好记性不如烂笔头，以前没有体会到这一点儿的好，在经过一个项目的总结之后，看到同事在做一个项目的总结文档和自己的一比，才知道，原来实时记录自己所学，所想的重要性，成功是一点儿一点儿积累起来的；二来，也是便于自己经常的复习所学的
哈夫曼（Huffman）树 & 哈夫曼编码与解码
最新发布
Xiaoyuan_he的博客
04-20 5437
哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。：WPL(Weighted Path Length)是树中所有叶子结点的带权路径长度之和。
接着学习C++哈夫曼编码
webgpu
02-18 276
昨天 已经构建了哈弗曼树了。哈夫曼编码 就是从底倒着往前走 如果这点是左子 0右子1 直到根  而且每个编码都不能是别的编码的前缀 上完整马 看注释哈 #ifndef H_HPP #define H_HPP #include //1 2 4 6 每两个顶点 都把权值相加合成一个新顶点 直到剩下一个点 就构建完成这个哈夫曼树了。 // // 13
文件压缩(Huaffman树的概念及其实现)
LXY的博客
01-14 450
什么是压缩 想办法让源文件变得更小并能还原。 为什么要进行文件压缩 文件太大，节省空间 提高数据再网络上传输的效率 对数据有保护作用—加密 文件压缩的分类 无损压缩 源文件被压缩后，通过解压缩能够还原成和源文件完全相同的格式 有损压缩 解压缩之后不能将其还原成与源文件完全相同的格式–解压缩之后的文件再识别其内容时基本没有影响 GZIP压缩 LZ77变形: 原理将重复出现得语句用...
Huffman 编码图像无损压缩和解压缩 Python示例代码 哈夫曼编码
08-13
本程序实现了利用 Huffman 编码对图像进行无损压缩和解压缩。Huffman 编码是一种基于字符出现频率构建相应前缀码的无损数据压缩算法。 使用方法： 1. 需要安装 OpenCV 和 Numpy 库： pip install opencv-python ...
Huffman编码测试文件
12-03
Huffman编码是一种基于频率的无损数据压缩方法，由David A. Huffman于1952年提出。在信息论和计算机科学中，它被广泛应用于文本、图像、音频和其他类型的数据压缩。这个压缩包文件“Huffman编码测试文件”包含了各种...
基于Matlab的图像Huffman编码的实现
12-27
Huffman编码是一种基于频率的无损数据压缩方法，最初由D.E. Huffman在1952年提出。本项目实现了在Matlab环境下对图像进行Huffman编码的过程，包括图像的灰度化、编码、解码以及计算压缩比和执行时间。 首先，我们要...
python三叉树实现三元huffman编码
12-21
在信息论领域，哈夫曼编码（Huffman Coding）是一种高效的数据压缩算法，它通过构建特殊的二叉树（哈夫曼树）来为输入符号分配最短的编码，以达到最小化平均编码长度的目的。在Python中，我们可以利用数据结构来实现...
huffman编码
02-22
哈夫曼编码（Huffman Coding）是一种数据压缩算法，由美国计算机科学家大卫·艾尔文·哈夫曼在1952年提出。这个算法基于字符出现频率构建一棵特殊的二叉树，称为哈夫曼树，进而为每个字符生成唯一的二进制编码，即...
Huffman算法与解析
cprimesplus的博客
05-06 7849
Huffman算法 解决的问题   ex.在传输电文时，每种字符出现的频率不同，想让电文在能够表达其意思的前提下尽可能短，自然需要让出现频率高的字符占的位数尽可能少。 思想   Huffman算法的核心是贪心算法。想要达到上面所述的目的，就需要让权重高的字符编码位数尽可能低。   假设共有五个字符，对应的权重分别是：123451234512345，按照贪心的策略，每次选出频率最小的两个结点构成一...
huffman编码——原理与实现
Rachel Zhang的专栏
09-26 9万+
哈夫曼算法原理 Wikipedia上面说的很清楚了，这里我就不再赘述，直接贴过来了。 1952年, David A. Huffman提出了一个不同的算法，这个算法可以为任何的可能性提供出一个理想的树。香农-范诺编码（Shanno-Fano）是从树的根节点到叶子节点所进行的的编码，哈夫曼编码算法却是从相反的方向，暨从叶子节点到根节点的方向编码的。 为每个符号建立一个叶子节点
哈夫曼编码的理解(Huffman Coding)
热门推荐
Never-Giveup的博客
08-15 11万+
哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。 哈夫曼编码，主要目的是根据使用频率来最大化节省字符（编码）的存储空间。 首先，计算机通过0-1进行运算，因此自...
数据结构和算法——Huffman树和Huffman编码
null的专栏
02-04 5万+
Huffman树是一种特殊结构的二叉树，由Huffman树设计的二进制前缀编码，也称为Huffman编码在通信领域有着广泛的应用。在word2vec模型中，在构建层次Softmax的过程中，也使用到了Huffman树的知识。在通信中，需要将传输的文字转换成二进制的字符串，假设传输的报文为：“AFTERDATAEARAREARTAREA”，现在需要对该报文进行编码。一、Huffman树的基本概念在二叉
堆(优先队列)求huffman WPL
dongchuan5097的博客
07-16 165
huffman编码中WPL等于没个结点到根结点的距离乘结点权值的总和，但我们也可以用另一种方法求WPL:如果huffman树只有一个结点，则WPL为根结点权值，否则WPL等于除了根结点以外的所有结点的权值之和。 我们可以用优先队列／堆实现这个过程： 1 //用优先队列求huffman编码中的WPL 2 #include <iostream> 3 using ...
[C/C++] 构造最优二叉树－赫夫曼(哈夫曼、Huffman)树算法实现
11-16 7996
一、基本概念1、赫夫曼（Huffman）树又称最优二叉树或最优搜索树，是一种带权路径长度最短的二叉树。在许多应用中，常常赋给树中结点一个有某种意义的实数，称此实数为该结点的权。从树根结点到该结点之间的路径长度与该结点上权的乘积称为结点的带权路径长度(WPL)，树中所有叶子结点的带权路径长度之和称为该树的带权路径长度，通常记为：2、两结点间的路径：从一结点到另一结点所经过的结点序列;路径长度：从根结点到相应结点路径上的分支数目;树的路径长度：从根到每一结点的路径长度之和。3、深度为k，结点数为n的二叉树，当且
OpenJudge Huffman编码树
kucece的专栏
05-23 2113
Huffman编码树 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65535kB 描述 构造一个具有n个外部节点的扩充二叉树，每个外部节点Ki有一个Wi对应，作为该外部节点的权。使得这个扩充二叉树的叶节点带权外部路径长度总和最小：                                      Min( W1 * L1 + W2 * L2 +
JPEG标准推荐的亮度、色度DC、AC Huffman编码表
weixin_30325071的博客
06-01 1382
JPEG 标准推荐的亮度、色度DC、AC Huffman 编码表 博主在完成数字图像处理大作业时利用搜索引擎查找了很久完整的四张Huffman 编码表(亮度AC Huffman编码表、亮度DC Huffman编码表、色度AC Huffman编码表、色度DC Huffman编码表)，发现中文博客中的编码表大都不完整或者排版混乱，不知所云；英文博客中也几乎没有相关内容。最后查看JPEG标准文...
自适应Huffman编码实现与优化
"这篇文档主要介绍了Huffman编码，特别是自适应Huffman编码的概念、原理以及C语言实现。Huffman编码是一种基于字符出现概率的数据压缩算法，通过构建最优的二叉树结构来达到压缩效果，频繁出现的字符对应短编码，不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值