哈夫曼树代码实现

已于 2024-01-17 22:36:54 修改
阅读量2.4k 收藏 44
点赞数 63
分类专栏： 数据结构 文章标签： 数据结构 c++ 霍夫曼树 c语言 算法 考研
于 2024-01-07 02:39:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52656735/article/details/135430385
版权
本文详细介绍了哈夫曼树的概念，包括结点的权值和带权路径长度的定义，以及如何通过构造过程生成哈夫曼树，计算其带权路径长度，并实现固定长度编码和哈夫曼编码。提供了完整的代码示例和程序运行截图。
摘要由CSDN通过智能技术生成

目录

哈夫曼树的相关概念

结点的权值： 某种特定含义的数值
结点的带权路径长度： 根到结点路径长度×结点的权值
树的带权路径长度： 所有叶子结点的带权路径长度之和
哈夫曼树： 在给定叶子结点权值的二叉树中带权路径长度最小的二叉树
固定长度编码： 在数据通信中，对每个字符用相等长度的二进制位表示的编码方式
可变长度编码： 对频率高的字符短编码，对频率低的字符长编码从而使平均编码长度减短的编码方式
哈夫曼编码： 由哈夫曼树得到的一种被广泛应用且非常有效的数据压缩编码

哈夫曼树的存储结构

采用二叉树的顺序存储方式来存储哈夫曼树。
代码

//哈夫曼树的结点
typedef struct HTNode {
    int weight; //权值
    int parent; //双亲下标
    int lChild; //左孩子下标
    int rChild; //右孩子下标
} HTNode;

//哈夫曼树
typedef struct HT {
    int numLeaf; //叶子结点树
    int WPL; //带权路径长度
    char **code; //哈夫曼编码
    HTNode *node; //树的结点
} HT;

初始化哈夫曼树

过程
给定5个结点权值分别为1，3，2，7，2，初始化后数据结构如下表：

结点下标结点权值父结点下标左孩子下标右孩子下标
01-1-1-1
13-1-1-1
22-1-1-1
37-1-1-1
42-1-1-1

代码

//初始化哈夫曼树
void initHT(HT *ht) {
    printf("叶子结点数：");
    scanf("%d", &ht->numLeaf); //获取叶子结点树
    ht->node = (HTNode *) malloc(sizeof(HTNode) * (2 * ht->numLeaf - 1)); //哈夫曼树总结点数始终为叶子结点数的两倍减一
    for (int i = 0; i < ht->numLeaf; i++) {
        //循环给每个叶子结点赋予权值
        printf("第%d个叶子结点权值：", i + 1);
        scanf("%d", &ht->node[i].weight); //给第i个叶子结点赋予权值
        ht->node[i].parent = ht->node[i].lChild = ht->node[i].rChild = -1; //将所有叶子结点的双亲下标初始化为-1
    }
    ht->code = (char **) malloc(sizeof(char *) * ht->numLeaf); //存储每一个叶子结点的哈夫曼编码
    for (int i = 0; i < ht->numLeaf; i++) {
        //初始化哈夫曼编码数组
        ht->code[i] = (char *) malloc(sizeof(char) * ht->numLeaf); //哈夫曼编码不会超过叶子结点数量减一最后一位存'\0'
        memset(ht->code[i], '\0', sizeof(char *)); //给每个字符串附上初值
    }
    ht->WPL = 0; //初始化带权路径长度
}

构造哈夫曼树

过程
哈夫曼树的构造过程
哈夫曼树构建完成后上述例子的数据结构如下表：

结点下标结点权值父结点下标左孩子下标右孩子下标
015-1-1
136-1-1
225-1-1
378-1-1
426-1-1
53702
65741
78856
815-137

代码

//构造哈夫曼树
void createHT(const HT *ht) {
    for (int i = 0; i < ht->numLeaf - 1; i++) {
        //一共要合并叶子结点数减一次
        int minNode1 = -1, minNode2 = -1, minWeight1 = INT_MAX, minWeight2 = INT_MAX; //记录没有双亲的最小的两个结点的下标和权值
        for (int j = 0; j < ht->numLeaf + i; j++) {
            //合并后的新结点也要参与筛选
            if (ht->node[j].weight < minWeight2 && ht->node[j].parent == -1) {
                minWeight2 = ht->node[j].weight;
                minNode2 = j;
                if (minWeight1 > minWeight2) {
                    //如果之前的权值比新选的大交换它们
                    minWeight2 = minWeight1;
                    minNode2 = minNode1;
                    minWeight1 = ht->node[j].weight;
                    minNode1 = j;
                }
            }
        }
        ht->node[minNode1].parent = ht->node[minNode2].parent = ht->numLeaf + i; //确定双亲结点的下标
        ht->node[ht->numLeaf + i].weight = minWeight1 + minWeight2; //给双亲结点赋予权值
        ht->node[ht->numLeaf + i].parent = -1; //将双亲结点的双亲结点下标初始化为-1
        ht->node[ht->numLeaf + i].lChild = minNode1; //确定双亲结点的左孩子下标
        ht->node[ht->numLeaf + i].rChild = minNode2; //确定双亲结点的右孩子下标
    }
}

计算带权路径长度

过程
带权路径长度等于所有叶子结点的带权路径长度之和
计算带权路径长度
W P L = 1 × 80 + 2 × 10 + 3 × ( 2 + 8 ) = 130 WPL=1×80+2×10+3×(2+8)=130 WPL=1×80+2×10+3×(2+8)=130

代码

//计算带权路径长度
void calculateWPL(HT *ht) {
    for (int i = 0; i < ht->numLeaf; i++) {
        //从每个叶子结点开始寻找根结点
        const HTNode *p = &ht->node[i]; //依次记录每个叶子结点地址
        int length = 0; //记录叶子结点到根结点的路径长度
        while (p->parent != -1) {
            //没有找到根结点继续向上搜寻
            p = &ht->node[p->parent]; //p指向当前结点的双亲
            length++; //路径长增加
        }
        ht->WPL += ht->node[i].weight * length; //带权路径长度等于所有叶子结点的带权路径长度之和
    }
}

构建哈夫曼树编码

过程
固定长度编码
固定长度编码

结点编码
A00
B01
C10
D11

哈夫曼树编码
哈夫曼树编码

结点编码
A00
B010
C1
D011

对于上述两种编码方式
压缩率 = W P L 哈夫曼树编码 W P L 固定长度编码 × 100 % = 130 200 × 100 % = 65 % 压缩率=\frac{WPL_{哈夫曼树编码}}{WPL_{固定长度编码}} ×100\%= \frac{130}{200} ×100\%=65\% 压缩率=WPL固定长度编码​WPL哈夫曼树编码​​×100%=200130​×100%=65%

代码

//构建哈夫曼编码
void createHC(const HT *ht) {
    for (int i = 0; i < ht->numLeaf; i++) {
        //从每个叶子结点开始寻找根结点
        const HTNode *p = &ht->node[i]; //依次记录每个叶子结点地址
        for (int j = 0; p->parent != -1; j++) {
            //没有找到根结点继续向上搜寻
            if (p == &ht->node[ht->node[p->parent].lChild]) {
                ht->code[i][j] = '0'; //如果当前结点是双亲的左孩子编码为0
            } else {
                ht->code[i][j] = '1'; //如果当前结点是双亲的右孩子编码为1
            }
            p = &ht->node[p->parent]; //p指向当前结点的双亲
        }
        strrev(ht->code[i]); //反转字符串
    }
}

完整实现代码

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

//哈夫曼树的结点
typedef struct HTNode {
    int weight; //权值
    int parent; //双亲下标
    int lChild; //左孩子下标
    int rChild; //右孩子下标
} HTNode;

//哈夫曼树
typedef struct HT {
    int numLeaf; //叶子结点树
    int WPL; //带权路径长度
    char **code; //哈夫曼编码
    HTNode *node; //树的结点
} HT;

//初始化哈夫曼树
void initHT(HT *ht) {
    printf("叶子结点数：");
    scanf("%d", &ht->numLeaf); //获取叶子结点树
    ht->node = (HTNode *) malloc(sizeof(HTNode) * (2 * ht->numLeaf - 1)); //哈夫曼树总结点数始终为叶子结点数的两倍减一
    for (int i = 0; i < ht->numLeaf; i++) {
        //循环给每个叶子结点赋予权值
        printf("第%d个叶子结点权值：", i + 1);
        scanf("%d", &ht->node[i].weight); //给第i个叶子结点赋予权值
        ht->node[i].parent = ht->node[i].lChild = ht->node[i].rChild = -1; //将所有叶子结点的双亲下标初始化为-1
    }
    ht->code = (char **) malloc(sizeof(char *) * ht->numLeaf); //存储每一个叶子结点的哈夫曼编码
    for (int i = 0; i < ht->numLeaf; i++) {
        //初始化哈夫曼编码数组
        ht->code[i] = (char *) malloc(sizeof(char) * ht->numLeaf); //哈夫曼编码不会超过叶子结点数量减一最后一位存'\0'
        memset(ht->code[i], '\0', sizeof(char *)); //给每个字符串附上初值
    }
    ht->WPL = 0; //初始化带权路径长度
}

//构造哈夫曼树
void createHT(const HT *ht) {
    for (int i = 0; i < ht->numLeaf - 1; i++) {
        //一共要合并叶子结点数减一次
        int minNode1 = -1, minNode2 = -1, minWeight1 = INT_MAX, minWeight2 = INT_MAX; //记录没有双亲的最小的两个结点的下标和权值
        for (int j = 0; j < ht->numLeaf + i; j++) {
            //合并后的新结点也要参与筛选
            if (ht->node[j].weight < minWeight2 && ht->node[j].parent == -1) {
                minWeight2 = ht->node[j].weight;
                minNode2 = j;
                if (minWeight1 > minWeight2) {
                    //如果之前的权值比新选的大交换它们
                    minWeight2 = minWeight1;
                    minNode2 = minNode1;
                    minWeight1 = ht->node[j].weight;
                    minNode1 = j;
                }
            }
        }
        ht->node[minNode1].parent = ht->node[minNode2].parent = ht->numLeaf + i; //确定双亲结点的下标
        ht->node[ht->numLeaf + i].weight = minWeight1 + minWeight2; //给双亲结点赋予权值
        ht->node[ht->numLeaf + i].parent = -1; //将双亲结点的双亲结点下标初始化为-1
        ht->node[ht->numLeaf + i].lChild = minNode1; //确定双亲结点的左孩子下标
        ht->node[ht->numLeaf + i].rChild = minNode2; //确定双亲结点的右孩子下标
    }
}

//计算带权路径长度
void calculateWPL(HT *ht) {
    for (int i = 0; i < ht->numLeaf; i++) {
        //从每个叶子结点开始寻找根结点
        const HTNode *p = &ht->node[i]; //依次记录每个叶子结点地址
        int length = 0; //记录叶子结点到根结点的路径长度
        while (p->parent != -1) {
            //没有找到根结点继续向上搜寻
            p = &ht->node[p->parent]; //p指向当前结点的双亲
            length++; //路径长增加
        }
        ht->WPL += ht->node[i].weight * length; //带权路径长度等于所有叶子结点的带权路径长度之和
    }
}

//构建哈夫曼编码
void createHC(const HT *ht) {
    for (int i = 0; i < ht->numLeaf; i++) {
        //从每个叶子结点开始寻找根结点
        const HTNode *p = &ht->node[i]; //依次记录每个叶子结点地址
        for (int j = 0; p->parent != -1; j++) {
            //没有找到根结点继续向上搜寻
            if (p == &ht->node[ht->node[p->parent].lChild]) {
                ht->code[i][j] = '0'; //如果当前结点是双亲的左孩子编码为0
            } else {
                ht->code[i][j] = '1'; //如果当前结点是双亲的右孩子编码为1
            }
            p = &ht->node[p->parent]; //p指向当前结点的双亲
        }
        strrev(ht->code[i]); //反转字符串
    }
}

//展示哈夫曼树信息
void showHT(const HT *ht) {
    printf("结点下标    结点权值    双亲下标    左孩子下标  右孩子下标  哈夫曼编码\n");
    for (int i = 0; i < 2 * ht->numLeaf - 1; i++) {
        printf("%-12d%-12d%-12d%-12d%-12d", i, ht->node[i].weight, ht->node[i].parent, ht->node[i].lChild,
               ht->node[i].rChild); //打印哈夫曼树结点的信息
        if (i < ht->numLeaf) {
            printf("%-12s", ht->code[i]); //打印每个叶子结点的哈夫曼编码
        }
        printf("\n");
    }
    printf("带权路径长度WPL=%d\n", ht->WPL); //打印带权路径长度
}

//测试代码
void test() {
    HT ht; //定义哈夫曼树
    initHT(&ht); //初始化哈夫曼树
    createHT(&ht); //构造哈夫曼树
    createHC(&ht); //计算哈夫曼编码
    calculateWPL(&ht); //计算带权路径长度
    showHT(&ht); //展示哈夫曼树信息
}

//主函数
int main() {
    test(); //测试代码
    system("pause"); //暂停
    return 0;
}

程序运行截图

程序运行截图

花园宝宝没有天线
关注
  • 63
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
哈夫曼树编码的实现+图解（含全部代码）
Initial_Mind的博客
04-23 8万+
只能说太用心了
基于C语言的哈夫曼树的实现(包含完整代码)
weixin_43369883的博客
05-24 2152
在许多应用中，树中结点常常被赋予一个表示某种意义的数值，称为该结点的权。从树的根到任意结点的路径长度(经过的边数)与该结点上权值的乘积，称为该结点的带权路径长度。树中所有叶结点的带权路径长度之和称为该树的带权路径长度. 在含有n个带权叶结点的二叉树中，其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也称最优二叉树。
【数据结构X.11】代码实现 哈夫曼树的创建，建立，构造，实现哈夫曼编码
清凌的博客
12-13 1903
哈夫曼树的各种语言java，python，c++ 代码实现哈夫曼树的创建，建立，构造，实现哈夫曼编码，实现思路和要点： 抓住哈夫曼树的性质，每轮选出2个权值最小的点进行构造树。 抓住哈夫曼编码的性质，从根出发，向左标0，向右标1. 哈夫曼树的构造思路： 已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11 试着设计赫夫曼编码。 假设权w=（5，29，7，8，14，23，3，11），n=8，则m=15，按照上述算法构造一颗哈夫曼树
【数据结构C/C++】C语言哈夫曼编码与解码实现细则(附代码以及详细实现解释)
Zhangsama1的博客
11-21 1万+
哈夫曼树作为最常见的考研树题目，拥有强大的压缩功能。 这篇文章将带你了解哈夫曼树如何实现编码与解码
哈夫曼树（C++实现）
Edison's 小宇宙
08-25 3万+
哈夫曼树的概念：在含有 n 个带权叶节点的二叉树中，其中带权路径长度（WPL）最小的二叉树，也叫做最优二叉树。
关于哈夫曼树代码实现
07-29
本文主要是对哈夫曼树代码进行介绍，感性趣的朋友可以参考下。
C语言实现哈夫曼树
12-20
本文实例为大家分享了C语言实现哈夫曼树的具体代码，供大家参考，具体内容如下 //哈夫曼树C语言实现 #include #include typedef struct HuffmanNode { char letter;//存储的字符，叶节点为字母，非叶节点为# ...
C++实现哈夫曼树算法
08-19
主要为大家详细介绍了C++实现哈夫曼树的具体代码，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
图文详解JAVA实现哈夫曼树
09-01
所谓哈夫曼树就是要求最小加权路径长度，这是什么意思呢？简而言之，就是要所有的节点对应的路径长度（高度-1）乘以该节点的权值，然后保证这些结果之和最小。下面这篇文章就给大家详细介绍
哈夫曼树及其编码 数据结构课程设计 （源代码附实验报告）
09-09
哈夫曼树及其编码 数据结构课程设计 （源代码附实验报告） 已调试成功
哈夫曼树代码实现(数据结构课设)
06-02
这是数据结构课设 哈夫曼树的c语言实现 大家可以借鉴一下
数据结构，哈夫曼树编码
06-27
可以打开文档读取文档中的字符，并对其进行哈夫曼编码，生成哈夫曼代码，保存至文档。还可以在对编码进行译码，保存至文档。
【数据结构】树（七）—— 哈夫曼树（C语言版）
haoweixl的博客
07-04 7932
【数据结构】树（七）—— 哈夫曼树（C语言版）前言哈夫曼树的定义哈夫曼树的应用——哈夫曼编码 前言 哈夫曼树的定义 哈夫曼树的应用——哈夫曼编码
【数据结构】哈夫曼树及哈夫曼编码实现（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 个带权叶子结点构成的所有二叉树中带权路径长度最短的
哈夫曼树的构造及C++代码实现
YuxiaoCyuyan的博客
11-18 2544
哈夫曼树的构造具体实现（c++）
数据结构——详解哈夫曼树及哈夫曼编码与其具体代码实现
诶你爱我吗的博客
12-27 3831
哈夫曼树 首先我们需要明白什么是哈夫曼树： 概念上说，哈夫曼树是给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。 叶子结点的权值：对叶子结点赋予的一个有意义的数值量。 二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为： 看起来好像有点抽象，那么我来解释一下： 比如我们给定4个叶子结点，其权值分别为{2，3，4，...
数据结构【完整代码】之（C语言实现【哈夫曼树的存储结构与创建】）
Zhou_LC的博客
11-28 1375
本文包含两个文件的代码和一张测试效果图： HuffmanTree.h文件： 哈夫曼树的存储结构与创建函数 HuffmanCreatTest.cpp文件： 用于测试 效果图：（如下） 效果图： HuffmanTree.h文件： #include <stdio.h> #include <stdlib.h> typedef struct{ int weight; int parent,lchild,rchild; }HTNode, *HuffmanTree; void S
哈夫曼树详细讲解（带例题和C语言代码实现——全注释）
qq_41199852的博客
12-02 1万+
** 哈夫曼树详细讲解（带例题和C语言代码实现——全注释） ** 定义
用c语言哈夫曼树代码实现
最新发布
12-08
以下是C语言实现哈夫曼树的代码示例： ```c #include #include #include #define MAX_TREE_HT 100 struct MinHeapNode { char data; unsigned freq; struct MinHeapNode *left, *right; }; struct MinHeap...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

花园宝宝没有天线

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

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

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

打赏作者

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

抵扣说明：

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

余额充值