哈夫曼编码的实现

最新推荐文章于 2024-08-19 18:00:26 发布
最新推荐文章于 2024-08-19 18:00:26 发布
阅读量5.6w 收藏 285
点赞数 48
分类专栏： # 贪心
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38846633/article/details/85038037
版权

前言  

哈夫曼编码是一种结合二叉树与贪心算法的文字、数据编码方式。具有较广的应用背景，最直观的应用便是文件压缩。举例说明，有一串多个字符组成的字符串“abbcccddddeeeee”，该字符串包含有五个字符，abcde五个字符分别出现的次数为1，2，3，4，5.。由于一个字符需要由多个二进制位进行表示，为了不混淆字符，需要用3个二进制位来表示字符才可以确保5种不同的组合（2^{3}=8>5），这串字符一共需要3*15=45位来表示。将信息一个不落地表示需要满足每一个单元信息的互异性，同时也要按原有的顺序来将信息写出。而这串信息中每个字符的哈夫曼对应为 a-010 b-011 c -00 d-10 e-11,此时的字符串需3*1+3*2+2*3+2*4+2*5=33位来表示。通过将高频率字符用较短字节进行表示而不是统一表示的方法达到字符串的压缩。

 

正文

1.哈夫曼编码的概念

哈夫曼树又称作最优树，是一种带权路径长度最短的树，而通过哈夫曼树构造出的编码方式称作哈夫曼编码。先补充以下三个概念：

1）路径长度

二叉树中一个结点到另一个结点经过的结点方式是唯一的，这些经过的结点称作两个结点之间的路径。而由结点A到结点B中间经历的结点数目加1即为结点A到B的路径长度。

2）结点权值

图当中，每一个结点代表着不同的数字，而这些不同的数字称作结点的权值。

3）带权路径长度

假设同样的例子，由结点A到结点B的过程中，经过的路径长度为3，结点B的权值为4。则3*4=12称作结点的带权路径长度。到结点的带权路径长度计算方式为路径长度乘结点的权值。而树的带权路径长度，意为树的根结点到所有的叶子结点的带权路径长度之和。表达公式如下：

                                                  WPL=\sum_{i=1}^{n}w_{i}*l_{i}                      

WPL代表树的带权路径长度，w_{i}代表树叶子结点的权值，l_{k}代表根结点到每个叶子结点的路径长度。

哈夫曼树必须要求WPL达到最短，而哈夫曼编码的编写方式，则要求将所有需要编码的元素放置在哈夫曼树的叶子结点上，方便编码。

2.哈夫曼编码的构造方法

哈夫曼编码在编写的过程中，要求先构造哈夫曼树。遵照的是权值最小原则，以前言中提到的字符串为例，字符 a的权值赋值为1，字符b的权值赋值为2，c的权值赋值为3，d的权值赋值为4，e的权值赋值为5。

1）选取权值最小的两个点1 2,将两个点作为叶子结点。1作为左孩子，2作为右孩子构造一棵新二叉树，根结点的权值为两叶子结点之和3。

2）将新的根结点作为叶子结点考虑，比较权值为{3，3，4，5}的四个结点，得出权值最小的为3和3。与第一步类似，以这两个点作为叶子结点，构造一棵新二叉树，根结点的权值为两叶子结点之和6。

3）此时集合为{4，5，6}三个结点，此处集合权值最小的两个点为 4 5，则将4，5作为叶子结点。4作为左孩子，5作为右孩子构造一棵新的二叉树，根结点权值为9

4）最后集合为{6，9}，将两个点合并为一棵二叉树。6作为左孩子，9作为右孩子，根结点为15。

 构造哈夫曼树的情况如下：

案例哈夫曼树的构造

构造完毕哈夫曼树后，由根结点开始对叶子结点进行编码，要求根结点的左子树添加的数字为0，右子树添加的数字为1，将左右子树分别作为根结点继续向下添加编码。一直添加数字到每个叶子结点为止。叶子结点对应的数字是这个叶子元素的哈夫曼编码。编码结果为： a-010 b-011 c -00 d-10 e-11，哈夫曼编码的过程如下：

案例的哈夫曼编码

3.哈夫曼编码构造的代码实现

在了解了哈夫曼编码的原理后，需要开始进行哈夫曼编码的实现，实现过程中主要有三个难点，其一是二叉树的构造，其二是最小值的挑选，其三是一维的数组如何转换为二叉树的结构。可以对节点进行编号，用编号来访问具有父子关系的结点。基本思路如下：

1）分析哈夫曼树的结构以及结点数目关系

假设哈夫曼树具有m个结点,叶子结点的数目为n，则不难得出 m=2*n-1 。建立一个哈夫曼树类的结点，其中类的变量包括权值weight，左孩子的下标lchild，右孩子的下标rchild，父结点的下标parent，类的一个构造函数记作HTNode(int w,int p,int l,int r)。用于进行哈夫曼树结点的初始化以及赋值。同链表的想法类似，类的单个对象记作HTnode,定义一个类的指针对象HuffmanTree.

类的代码如下：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

typedef struct HTNode
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    HTNode(int w,int p,int l,int r):weight(w),parent(p),lchild(l),rchild(r){}
}HTnode,*HuffmanTree;

2）函数基本结构的实现

定义一个哈夫曼编码加密函数Huffmancoding()，其中函数的自变量包括HuffmanTree类型的对象数组HT，定义一个二维的字符指针Huffmancode，Huffmancode的对象名称记作HC。分成多行，用于存储abcde五个待编码的字符，每一个字符都对应的编码均存储在Huffmancode的每一行中。定义一个int型指针，记作w，w指向的数组用于存储每一个字符的权值。最后需要定义变量n，记录下叶子结点的数目，同时根据叶子结点的数目也可以推断出包括根结点在内的所有结点的数目。函数声明如下:

typedef char**Huffmancode;
void Huffmancode(HuffmanTree &HT,Huffmancode &HC,int *w,int n);

在定义完成该输入的变量后，定义int类型的变量记作m与i。m代表结点的数目，同时也控制着HT对象内存的分配，i控制着循环。对于下标为1到n的结点，控制它们承担叶子结点的信息，相应地，初始化时将结点的权值与w中的各个数字相互对应，父子结点以及左右孩子的信息均初始化为0。对于下标n+1到m的结点，初始化值均设为0。HT对象内存分配以及叶子结点初始化代码如下:

m=n*2-1;
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
for(i=1;i<=n;i++,w++)
{
    HT[i]=HTNode(*w,0,0,0);
}
for(;i<=m;i++)
{
    HT[i]=HTNode(0,0,0,0);
}

在结点初始化完成后，需要完善的是对应父子结点的信息，对于不同下标的结点进行结点内部元素的赋值，达到构建二叉树的效果。

假设存在一个待实现的Select函数，找到权值最小的两个点的下标，实现放到3）实现Select函数来讲，两个权值最小的结点下标为child1,child2。通过for循环，i 的值初始化为n+1，最后到达m为止，i 每一次都增加1。将HT[i]作为HT[child1]与HT[child2]的父亲结点，将对应的权值以及左右孩子值均赋上。通过for循环中存在的 i+1操作将新产生的HT[i]结点加入待寻找权值最小的序列中。实现代码如下：

for(i=n+1;i<=m;i++)
{
    Select(HT,i-1,child1,child2);  //i-1=n时代表前n个结点中找权值最小的两个点，i++使得i=n+1
    HT[child1].parent=i;           //时的新产生的父结点被包括进来
    HT[child2].parent=i;
    HT[i].lchild=child1;
    HT[i].rchild=child2;
    HT[i].weight=HT[child1].weight+HT[child2].weight;
}

寻找了权值最小的两个结点HT[child1]，HT[child2]后，需要开始对待编码的字符进行编码。这里主要是运用了向上回溯的思想，通过对每个叶子结点的访问来达到编码的效果。给HC分配空间，定义字符指针cd,用来存储每一个字母对应的编码值。按照访问叶子结点的思路，先通过外层for循环来访问每一个叶子结点。访问叶子结点后，通过内层for循环向上回溯，添加内外for循环的语句如下：

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
    int m,i;
    int child1,child2;
    if(n<=1)
    {
        return;
    }
    m=n*2-1;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
    for(i=1;i<=n;i++,w++)
    {
        HT[i]=HTNode(*w,0,0,0);
    }
    for(;i<=m;i++)
    {
        HT[i]=HTNode(0,0,0,0);
    }
    for(i=n+1;i<=m;i++)
    {
        Select(HT,i-1,child1,child2);
        HT[child1].parent=i;
        HT[child2].parent=i;
        HT[i].lchild=child1;
        HT[i].rchild=child2;
        HT[i].weight=HT[child1].weight+HT[child2].weight;
    }
    HC=(char**)malloc((n+1)*sizeof(char*));
    char*cd=(char*)malloc(n*sizeof(char));
    int temp,count;
    for(i=1;i<=n;i++)
    {
        count=0;
        for(int c=i,temp=HT[i].parent;temp!=0;c=temp,temp=HT[temp].parent)
        {
            if(HT[temp].lchild==c)
            {
                cd[count++]='0';
            }
            else
            {
                cd[count++]='1';
            }
        }
        cd[count]='\0';
    }
}

其中c代表当前访问结点的下标，temp代表该结点父结点的下标，若当前结点是它父结点的左孩子，则在cd中添加上字符 ‘0’，若是右孩子，则在cd中添加上字符 ‘1’。每经过一次叶子结点的编码后cd均会更新。需要注意的是，将cd写入HC的每一行中时，需要将cd反向写入（由叶子结点向上回溯得到的编码是相反的），完整编码的代码如下：

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
    int m,i;
    int child1,child2;
    if(n<=1)
    {
        return;
    }
    m=n*2-1;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
    for(i=1;i<=n;i++,w++)
    {
        HT[i]=HTNode(*w,0,0,0);
    }
    for(;i<=m;i++)
    {
        HT[i]=HTNode(0,0,0,0);
    }
    for(i=n+1;i<=m;i++)
    {
        Select(HT,i-1,child1,child2);
        HT[child1].parent=i;
        HT[child2].parent=i;
        HT[i].lchild=child1;
        HT[i].rchild=child2;
        HT[i].weight=HT[child1].weight+HT[child2].weight;
        cout<<child1<<" "<<child2<<endl;
    }
    HC=(char**)malloc((n+1)*sizeof(char*));
    char*cd=(char*)malloc(n*sizeof(char));
    int temp,count;
    for(i=1;i<=n;i++)
    {
        count=0;
        for(int c=i,temp=HT[i].parent;temp!=0;c=temp,temp=HT[temp].parent)
        {
            if(HT[temp].lchild==c)
            {
                cd[count++]='0';
            }
            else
            {
                cd[count++]='1';
            }
        }
        cd[count]='\0';
        HC[i]=(char*)malloc((count)*sizeof(char));
        for(int j=count;j>=0;j--)
        {
            HC[i][count-j]=cd[j-1];//cd反向输入
        }
    }
}

3）实现Select函数

      按已经实现的想法来看，需要完成一个函数以对权值最小的两个结点进行合并，用一个函数Select完成对这两个权值最小结点的寻找，在其他函数中再对其进行实现。进行Select函数的函数自变量包括哈夫曼树对象HT，待寻找的结点集合下标最大值Num，以及两个权值最小的结点的下标child1,child2。经过此函数的目的，是将寻找到正确的child1与child2的值，使得在该次循环中HT[child1]与HT[child2]的权值达到最小。

     基本思路如下：1.判断HT[i].parent是否为0,若不为0,则代表这个结点已经被归入一棵树内，不能再次进行合并，为0则可以继续  2.child1,child2,w1,w2均初始化为0  3.通过（w1>w2）或（w2>w1）在 i 从 1 至Num中反复找最小权值的两个点，在多次的循环中child1与child2会反复更新，并且（w2>w1）条件在后保证了HT[child1]的权值要小于HT[child2]的权值。代码如下：

void Select(HuffmanTree &HT,int num,int &child1,int &child2)
{
    child1=0;
    child2=0;
    int w1=0;
    int w2=0;
    for(int i=1;i<=num;i++)
    {
        if(HT[i].parent==0)
        {
            if(child1==0)
            {
                child1=i;
                w1=HT[i].weight;
                continue;
            }
            if(child2==0)
            {
                child2=i;
                w2=HT[i].weight;
                continue;
            }
            if(w1>w2&&w1>HT[i].weight)
            {
                w1=HT[i].weight;
                child1=i;
                continue;
            }
            if(w2>w1&&w2>HT[i].weight)
            {
                w2=HT[i].weight;
                child2=i;
                continue;
            }
        }
    }
}

4）主函数的实现

相对以上步骤，主函数便极其容易，这里直接将 abcde 五个字符的权值存在数组中，直接输出了每个字符的编码，主程序如下：


int main()
{
    char a[]={'a','b','c','d','e'};
    int b[]={1,2,3,4,5};
    HuffmanTree HT;
    HuffmanCode HC;
    HuffmanCoding(HT,HC,b,5);
    for(int j=1;j<=5;j++)
    {
        cout<<a[j-1]<<" "<<HC[j]<<endl;
    }
    return 0;
}

编码结果如下所示：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

typedef struct HTNode
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    HTNode(int w,int p,int l,int r):weight(w),parent(p),lchild(l),rchild(r){}
}HTnode,*HuffmanTree;

typedef char** HuffmanCode;

void Select(HuffmanTree &HT,int num,int &child1,int &child2)
{
    child1=0;
    child2=0;
    int w1=0;
    int w2=0;
    for(int i=1;i<=num;i++)
    {
        if(HT[i].parent==0)
        {
            if(child1==0)
            {
                child1=i;
                w1=HT[i].weight;
                continue;
            }
            if(child2==0)
            {
                child2=i;
                w2=HT[i].weight;
                continue;
            }
            if(w1>w2&&w1>HT[i].weight)
            {
                w1=HT[i].weight;
                child1=i;
                continue;
            }
            if(w2>w1&&w2>HT[i].weight)
            {
                w2=HT[i].weight;
                child2=i;
                continue;
            }
        }
    }
}


//HuffmanCode是一个二维数组，用于存储字符
//HuffmanTree是一棵哈夫曼树
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
    int m,i;
    int child1,child2;
    if(n<=1)
    {
        return;
    }
    m=n*2-1;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
    for(i=1;i<=n;i++,w++)
    {
        HT[i]=HTNode(*w,0,0,0);
    }
    for(;i<=m;i++)
    {
        HT[i]=HTNode(0,0,0,0);
    }
    for(i=n+1;i<=m;i++)
    {
        Select(HT,i-1,child1,child2);
        HT[child1].parent=i;
        HT[child2].parent=i;
        HT[i].lchild=child1;
        HT[i].rchild=child2;
        HT[i].weight=HT[child1].weight+HT[child2].weight;
        //cout<<child1<<" "<<child2<<endl;
    }

    HC=(char**)malloc((n+1)*sizeof(char*));

    char*cd=(char*)malloc(n*sizeof(char));


    int temp,count;
    for(i=1;i<=n;i++)
    {
        count=0;
        for(int c=i,temp=HT[i].parent;temp!=0;c=temp,temp=HT[temp].parent)
        {
            if(HT[temp].lchild==c)
            {
                cd[count++]='0';
            }
            else
            {
                cd[count++]='1';
            }
        }
        cd[count]='\0';
        //cout<<cd<<" "<<i<<endl;
        HC[i]=(char*)malloc((count)*sizeof(char));
        for(int j=count;j>=0;j--)
        {
            HC[i][count-j]=cd[j-1];
        }
    }
}


int main()
{
    char a[]="abbcccddddeeeee";
    char c[]={'a','b','c','d','e'};
    int i=strlen(a);
    int b[]={1,2,3,4,5};
    HuffmanTree HT;
    HuffmanCode HC;
    HuffmanCoding(HT,HC,b,5);
    for(int j=1;j<=5;j++)
    {
        cout<<c[j-1]<<" "<<HC[j]<<endl;//此处似乎是用来进行字符的编码的？输出abcd四个字符所对应的编码
    }
    return 0;
}

 

时间领主大锤
关注
专栏目录
【数据结构】哈夫曼树及哈夫曼编码实现（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 个带权叶子结点构成的所有二叉树中带权路径长度最短的
用哈夫曼编码实现文件压缩（代码+报告）
04-04
数据结构课程设计用哈夫曼编码实现文件压缩： 一、实验题目： 用哈夫曼编码实现文件压缩 二、实验目的： 1、了解文件的概念。 2、掌握线性链表的插入、删除等算法。 3、掌握Huffman树的概念及构造方法。 4、掌握...
huffman编码实现
阿鲲的专栏
07-16 1819
 大概思路:        1.计算目标文件A中的字符出现频率,从而确定权值        2.由字符权值构建huffman树,结构体数组作为此树的数据结构        3.由huffman树将目标文件A中所出现的每个字符编码        4.用字符编码将目标文件编码到新文件B        5.将编码文件B译码为文件C /*******************
哈夫曼编码（小顶堆）
最新发布
qq_74143684的博客
08-19 657
哈夫曼编码是一种根据字符出现频率设计的变长编码方式，常用于数据压缩。它的基本思想是，将出现频率较高的字符用较短的编码表示，而出现频率较低的字符用较长的编码表示，从而减小编码的总长度。
haffman哈夫曼编码的实现
weixin_34256074的博客
04-14 210
&lt;span style="font-size:18px;"&gt;/* 1.在一棵二叉树中，我们定义从A节点到B节点所经过的分支序列为从A节点到B节点的路径； 定义从A节点到B节点所经过的分支个数为从A节点到B节点的路径长度。 定义从二叉树的根节点到二叉树中全部叶节点的路径长度之和为该二叉树的路径长度。 2.假设二叉树中的叶节点都带有权值，则能够把这个定义推广。设...
哈夫曼编码实现
weixin_52632501的博客
06-25 1141
哈夫曼编码的实现
实现哈夫曼编码
m0_49071428的博客
01-06 1466
算法设计与分析 实现哈夫曼编码
哈夫曼编码实现对文件的加密解密
12-03
在本项目中，我们利用哈夫曼编码实现了对文本文件的加密和解密功能，具体操作是针对ASCII字符集内的字符进行。以下是关于哈夫曼编码和其在文件加密解密中的应用的详细阐述： 1. **哈夫曼树的构建**： - 哈夫曼树是...
哈夫曼编码数据压缩_哈夫曼编码_哈夫曼编码实现数据压缩_
10-03
在提供的文件列表中，`main.c`可能是实现哈夫曼编码算法的C语言源代码，而`H.txt`和`A.txt`是待压缩的文本文件。`H.zip`可能是压缩后的结果，包含压缩后的文本和哈夫曼树信息。`2.cbp`和`2.layout`可能与开发环境或...
用哈夫曼编码实现文件压缩
12-10
在VC++6.0环境下，我们可以使用C++语言来实现哈夫曼编码的文件压缩过程。首先，我们需要创建一个结构体或类来表示哈夫曼树的节点，包含左子节点、右子节点以及节点的权重。权重通常代表字符在文件中的出现频率。 ``...
哈夫曼编码算法实现
12-21
哈夫曼编码算法实现 C实现 实验说明及实现文档
哈夫曼编码简单实现
小菜鸡
02-23 785
哈夫曼编码 基本介绍 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间 赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码 i like like like java do you like a java // 共40个字符(包括空格) 105 32
基本的哈夫曼编码算法的实现
qianligaoshan的专栏
04-19 1043
huffman.h文件 #include typedef int bool; #define false 0 #define true 1 typedef struct _CharNode{ int count; char name; int weight; bool flag; struct _CharNode *left; struct _CharNode *right; }C
Huffman编码实现
菜鸟的飞翔
07-31 503
严蔚敏《数据结构》
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值