【数据结构】【哈夫曼树】哈夫曼树、赫夫曼树（Huffman Tree）C语言实现

已于 2023-06-03 23:59:10 修改
阅读量3.3k 收藏 49
点赞数 9
分类专栏： 数据结构与算法 文章标签： c语言 c++ 数据结构 算法 霍夫曼树
于 2023-04-03 16:27:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crr411422/article/details/129932889
版权

目录

一、哈夫曼树定义与原理

二、构建哈夫曼树

三、哈夫曼编码

完整代码：

前言：章末含c语言实现完整代码

一、哈夫曼树定义与原理

        哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。

        树的路径长度是从树根到每一结点的路径长度之和，记为：

WPL=（W1*L1+W2*L2+W3*L3+...+Wn*Ln）

        N个权值Wi（i=1,2,...n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,...n）。可以证明哈夫曼树的WPL是最小的。

例：计算下面三棵二叉树的WPL

(a)WPL = 7*2+5*2+4*2+2*2 = 36

(b)WPL = 7*3+5*3+4*2+2*2 = 46

(c)WPL = 7*1+5*2+4*3+2*3 = 35

 其中(c)的带权路径WPL值最小，可以验证为哈夫曼树。

二、构建哈夫曼树

        对于给定的有各自权值的 n 个结点，构建哈夫曼树方法如下：

  1. 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；
  2. 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
  3. 重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。

哈夫曼树的构建过程图： 

前提：上图中，（A）给定了四个结点a，b，c，d，权值分别为7，5，2，4；

第一步：如（B）所示，找出现有权值中最小的两个，2 和 4 ，相应的结点 c 和 d 构建一个新的二叉树，树根的权值为 2 + 4 = 6；

第二步：将原有权值中的 2 和 4 删掉，将新的权值 6 加入；

第三步：进入（C），重复之前的步骤。直到（D）中，所有的结点构建成了一个全新的二叉树。

结点结构：

        构建哈夫曼树时，首先需要确定树中结点的构成。由于哈夫曼树的构建是从叶子结点开始，不断地构建新的父结点，直至树根，所以结点中应包含指向父结点的指针。但是在使用哈夫曼树时是从树根开始，根据需求遍历树中的结点，因此每个结点需要有指向其左孩子和右孩子的指针。


代码表示结点结构：

//哈夫曼树结点结构
typedef struct {
    int weight;//结点权重
    int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;

哈弗曼树中的查找算法：

        构建哈夫曼树时，需要每次根据各个结点的权重值，筛选出其中值最小的两个结点，然后构建二叉树。

        查找权重值最小的两个结点的思想是：从树组起始位置开始，首先找到两个无父结点的结点（说明还未使用其构建成树），然后和后续无父结点的结点依次做比较，有两种情况需要考虑：

  • 如果比两个结点中较小的那个还小，就保留这个结点，删除原来较大的结点；
  • 如果介于两个结点权重值之间，替换原来较大的结点；

代码实现：

//HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
void Select(HuffmanTree HT, int end, int *s1, int *s2)
{
    int min1, min2;
    //遍历数组初始下标为 1
    int i = 1;
    //找到还没构建树的结点
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    min1 = HT[i].weight;
    *s1 = i;
   
    i++;
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    //对找到的两个结点比较大小，min2为大的，min1为小的
    if(HT[i].weight < min1){
        min2 = min1;
        *s2 = *s1;
        min1 = HT[i].weight;
        *s1 = i;
    }else{
        min2 = HT[i].weight;
        *s2 = i;
    }
    //两个结点和后续的所有未构建成树的结点做比较
    for(int j=i+1; j <= end; j++)
    {
        //如果有父结点，直接跳过，进行下一个
        if(HT[j].parent != 0){
            continue;
        }
        //如果比最小的还小，将min2=min1，min1赋值新的结点的下标
        if(HT[j].weight < min1){
            min2 = min1;
            min1 = HT[j].weight;
            *s2 = *s1;
            *s1 = j;
        }
        //如果介于两者之间，min2赋值为新的结点的位置下标
        else if(HT[j].weight >= min1 && HT[j].weight < min2){
            min2 = HT[j].weight;
            *s2 = j;
        }
    }
}

三、哈夫曼编码

        哈夫曼编码就是在哈夫曼树的基础上构建的，这种编码方式最大的优点就是用最少的字符包含最多的信息内容。
        根据发送信息的内容，通过统计文本中相同字符的个数作为每个字符的权值，建立哈夫曼树。对于树中的每一个子树，统一规定其左孩子标记为 0 ，右孩子标记为 1 。这样，用到哪个字符时，从哈夫曼树的根结点开始，依次写出经过结点的标记，最终得到的就是该结点的哈夫曼编码。

文本中字符出现的次数越多，在哈夫曼树中的体现就是越接近树根。编码的长度越短。

        如上图所示，字符 a 用到的次数最多，其次是字符 b 。字符 a 在哈夫曼编码是 0 ，字符 b 编码为 10 ，字符 c 的编码为 110 ，字符 d 的编码为 111 。

哈夫曼编码有两种方法：

  1. 从叶子结点一直找到根结点，逆向记录途中经过的标记。例如，上图中字符 c 的哈夫曼编码从结点 c 开始一直找到根结点，结果为：0 1 1 ，所以字符 c 的哈夫曼编码为：1 1 0（逆序输出）。
  2. 从根结点出发，一直到叶子结点，记录途中经过的标记。例如，求上图中字符 c 的哈夫曼编码，就从根结点开始，依次为：1 1 0。

方法一实现：

//HT为哈夫曼树，HC为存储结点哈夫曼编码的二维动态数组，n为结点的个数
void HuffmanCoding(HuffmanTree HT, HuffmanCode *HC,int n){
    *HC = (HuffmanCode) malloc((n+1) * sizeof(char *));
    char *cd = (char *)malloc(n*sizeof(char)); //存放结点哈夫曼编码的字符串数组
    cd[n-1] = '\0';//字符串结束符
   
    for(int i=1; i<=n; i++){
        //从叶子结点出发，得到的哈夫曼编码是逆序的，需要在字符串数组中逆序存放
        int start = n-1;
        //当前结点在数组中的位置
        int c = i;
        //当前结点的父结点在数组中的位置
        int j = HT[i].parent;
        // 一直寻找到根结点
        while(j != 0){
            // 如果该结点是父结点的左孩子则对应路径编码为0，否则为右孩子编码为1
            if(HT[j].left == c)
                cd[--start] = '0';
            else
                cd[--start] = '1';
            //以父结点为孩子结点，继续朝树根的方向遍历
            c = j;
            j = HT[j].parent;
        }
        //跳出循环后，cd数组中从下标 start 开始，存放的就是该结点的哈夫曼编码
        (*HC)[i] = (char *)malloc((n-start)*sizeof(char));
        strcpy((*HC)[i], &cd[start]);
    }
    //使用malloc申请的cd动态数组需要手动释放
    free(cd);
}

 方法二实现：

//HT为哈夫曼树，HC为存储结点哈夫曼编码的二维动态数组，n为结点的个数
void HuffmanCoding(HuffmanTree HT, HuffmanCode *HC,int n){
    *HC = (HuffmanCode) malloc((n+1) * sizeof(char *));
    int m=2*n-1;
    int p=m;
    int cdlen=0;
    char *cd = (char *)malloc(n*sizeof(char));
    //将各个结点的权重用于记录访问结点的次数，首先初始化为0
    for (int i=1; i<=m; i++) {
        HT[i].weight=0;
    }
    //一开始 p 初始化为 m，也就是从树根开始。一直到p为0
    while (p) {
        //如果当前结点一次没有访问，进入这个if语句
        if (HT[p].weight==0) {
            HT[p].weight=1;//重置访问次数为1
            //如果有左孩子，则访问左孩子，并且存储走过的标记为0
            if (HT[p].left!=0) {
                p=HT[p].left;
                cd[cdlen++]='0';
            }
            //当前结点没有左孩子，也没有右孩子，说明为叶子结点，直接记录哈夫曼编码
            else if(HT[p].right==0){
                (*HC)[p]=(char*)malloc((cdlen+1)*sizeof(char));
                cd[cdlen]='\0';
                strcpy((*HC)[p], cd);
            }
        }
        //如果weight为1，说明访问过一次，即是从其左孩子返回的
        else if(HT[p].weight==1){
            HT[p].weight=2;//设置访问次数为2
            //如果有右孩子，遍历右孩子，记录标记值 1
            if (HT[p].right!=0) {
                p=HT[p].right;
                cd[cdlen++]='1';
            }
        }
        //如果访问次数为 2，说明左右孩子都遍历完了，返回父结点
        else{
            HT[p].weight=0;
            p=HT[p].parent;
            --cdlen;
        }
    }
}

完整代码：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
//哈夫曼树结点结构
typedef struct {
    int weight;//结点权重
    int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;
//动态二维数组，存储哈夫曼编码
typedef char ** HuffmanCode;
//HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
void Select(HuffmanTree HT, int end, int *s1, int *s2)
{
    int min1, min2;
    //遍历数组初始下标为 1
    int i = 1;
    //找到还没构建树的结点
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    min1 = HT[i].weight;
    *s1 = i;
   
    i++;
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    //对找到的两个结点比较大小，min2为大的，min1为小的
    if(HT[i].weight < min1){
        min2 = min1;
        *s2 = *s1;
        min1 = HT[i].weight;
        *s1 = i;
    }else{
        min2 = HT[i].weight;
        *s2 = i;
    }
    //两个结点和后续的所有未构建成树的结点做比较
    for(int j=i+1; j <= end; j++)
    {
        //如果有父结点，直接跳过，进行下一个
        if(HT[j].parent != 0){
            continue;
        }
        //如果比最小的还小，将min2=min1，min1赋值新的结点的下标
        if(HT[j].weight < min1){
            min2 = min1;
            min1 = HT[j].weight;
            *s2 = *s1;
            *s1 = j;
        }
        //如果介于两者之间，min2赋值为新的结点的位置下标
        else if(HT[j].weight >= min1 && HT[j].weight < min2){
            min2 = HT[j].weight;
            *s2 = j;
        }
    }
}
//HT为地址传递的存储哈夫曼树的数组，w为存储结点权重值的数组，n为结点个数
void CreateHuffmanTree(HuffmanTree *HT, int *w, int n)
{
    if(n<=1) return; // 如果只有一个编码就相当于0
    int m = 2*n-1; // 哈夫曼树总节点数，n就是叶子结点
    *HT = (HuffmanTree) malloc((m+1) * sizeof(HTNode)); // 0号位置不用
    HuffmanTree p = *HT;
    // 初始化哈夫曼树中的所有结点
    for(int i = 1; i <= n; i++)
    {
        (p+i)->weight = *(w+i-1);
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //从树组的下标 n+1 开始初始化哈夫曼树中除叶子结点外的结点
    for(int i = n+1; i <= m; i++)
    {
        (p+i)->weight = 0;
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //构建哈夫曼树
    for(int i = n+1; i <= m; i++)
    {
        int s1, s2;
        Select(*HT, i-1, &s1, &s2);
        (*HT)[s1].parent = (*HT)[s2].parent = i;
        (*HT)[i].left = s1;
        (*HT)[i].right = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
    }
}
//HT为哈夫曼树，HC为存储结点哈夫曼编码的二维动态数组，n为结点的个数
void HuffmanCoding(HuffmanTree HT, HuffmanCode *HC,int n){
    *HC = (HuffmanCode) malloc((n+1) * sizeof(char *));
    char *cd = (char *)malloc(n*sizeof(char)); //存放结点哈夫曼编码的字符串数组
    cd[n-1] = '\0';//字符串结束符
   
    for(int i=1; i<=n; i++){
        //从叶子结点出发，得到的哈夫曼编码是逆序的，需要在字符串数组中逆序存放
        int start = n-1;
        //当前结点在数组中的位置
        int c = i;
        //当前结点的父结点在数组中的位置
        int j = HT[i].parent;
        // 一直寻找到根结点
        while(j != 0){
            // 如果该结点是父结点的左孩子则对应路径编码为0，否则为右孩子编码为1
            if(HT[j].left == c)
                cd[--start] = '0';
            else
                cd[--start] = '1';
            //以父结点为孩子结点，继续朝树根的方向遍历
            c = j;
            j = HT[j].parent;
        }
        //跳出循环后，cd数组中从下标 start 开始，存放的就是该结点的哈夫曼编码
        (*HC)[i] = (char *)malloc((n-start)*sizeof(char));
        strcpy((*HC)[i], &cd[start]);
    }
    //使用malloc申请的cd动态数组需要手动释放
    free(cd);
}
//打印哈夫曼编码的函数
void PrintHuffmanCode(HuffmanCode htable,int *w,int n)
{
    printf("Huffman code : \n");
    for(int i = 1; i <= n; i++)
        printf("%d code = %s\n",w[i-1], htable[i]);
}
int main(void)
{
    int w[5] = {2, 8, 7, 6, 5};
    int n = 5;
    HuffmanTree htree;
    HuffmanCode htable;
    CreateHuffmanTree(&htree, w, n);
    HuffmanCoding(htree, &htable, n);
    PrintHuffmanCode(htable,w, n);
    return 0;
}
SecureCode
关注
专栏目录
数据结构 ---- 哈夫曼树****
m0_67509744的博客
05-29 436
给定N个权值作为N个叶子节点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 #include <iostream> #include <fstream> #include <string.h> using namespace std; #define MaxSize 1024 // 读入文件的上限 #define OK 1 #def
哈夫曼树（C语言）
chenshengnanii的博客
05-29 1779
一、定义 哈夫曼树（Huffman Tree）是在叶子结点和权重确定的情况下，带权路径长度最小的二叉树，也被称为最优二叉树。 二、代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #define N 30 #define Max 2*N-1 typedef char **HuffmanCode; typedef struct HTNode { double w..
[C语言]哈夫曼树(Huffman)的构造与实现
香菇的博客
05-13 8168
C语言编程数据结构中的哈弗曼树是非常重要的，哈夫曼主要是它的编码应用可以保证译码的非二义性。 每天坚持编写一个程序，持之以恒，我们就会更加熟练的进行编程，从而为以后打下基础。 下面是今天编写的HUffman树的源代码，因为纯手写，没有运行，了解了原理才是最重要的嘛！
哈夫曼树c语言实现
05-06
本例用c语言实现数据结构课程中的哈夫曼树，结构清晰，已编译通过
数据结构：N之后的问题和哈夫曼
m0_62600887的博客
05-28 374
N后问题：在n×n格的棋盘上放置彼此不受攻击的n个皇后，按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子，请输出皇后的位置以及对应皇后的解法个数。 照搬代码 #include<stdio.h> #include<malloc.h> #include<math.h> /* *place it there ,application */ bool place(int* paraSolution,int paraT){ i..
C语言实现哈夫曼树
2301_80073794的博客
12-11 1364
/节点权值char c;//节点名字i <= x;i++) {if (array[i].weight < min1 && array[i].parent == 0) {//在构建哈夫曼树的过程 //中，我们需要选择权重最小的两个结点进行合并，构建出新的结点。为了避免重复选择已经合并过的结点， //我们需要在选择最小权重结点的时候排除已经合并的结点。因此，需要通过array[i].parent == 0来判 //断结点是否已经是其他结点的子结点，如果是，则不考虑这个结点。*m1 = i;
哈夫曼树代码
06-08
自己写的简单一点关于哈夫曼树的应用，多交流啊
赫夫曼树的实现数据结构实验报告.doc
05-04
【赫夫曼树的实现与数据结构实验报告】 在计算机科学中，赫夫曼树（Huffman Tree）是一种特殊的二叉树，常用于数据压缩。赫夫曼编码是一种高效的无损数据压缩方法，通过构建赫夫曼树来为数据符号分配最短的二进制...
基于c语言实现哈夫曼树赫夫曼树
01-12
在C语言中实现哈夫曼树，可以帮助我们更深入地理解这种数据结构及其背后的算法。下面将详细介绍哈夫曼树的基本概念、构建过程以及如何在C语言中实现。 哈夫曼树是一种特殊的二叉树，其特性是每个叶子节点代表一个...
数据结构：哈夫曼树（HuffmanTree)
m0_65505275的博客
05-29 1368
哈夫曼树：给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 定义结构体： typedef struct wordcnt{ //统计字符和对应的次数 char ch; int cnt = 0; }; typedef struct NumCount{ //统计次数的外部封装 Count c...
哈夫曼树(c语言)
05-15
用C语言实现哈夫曼树，给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
哈夫曼树及其编码
12-27
华东交通大学C++课设第8题 数据结构课设，哈夫曼树，哈夫曼编码
数据结构课程设计_哈夫曼树
03-07
数据结构课程设计的目标是让学生能够灵活运用所学的数据结构知识，特别是哈夫曼树这一重要概念，来解决实际问题。哈夫曼树是一种特殊的二叉树，常用于数据压缩和编码，通过构建最小带权路径长度的二叉树，使得频率高...
字符串哈夫曼树C语言,哈夫曼树（赫夫曼树、最优树）及C语言实现
weixin_39681621的博客
05-17 740
赫夫曼哈夫曼树相关的几个名词路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 ...
哈夫曼树的代码
最新发布
A15276790381的博客
04-29 262
printf("请输入第%d个节点的权重：",i+1);
[数据结构] 哈夫曼树HuffmanTree、哈夫曼编码的c/c++语言实现
m0_46599531的博客
04-11 5300
[数据结构] 哈夫曼树HuffmanTree、哈夫曼编码的c/c++语言实现什么是哈夫曼树先给出定义公式:举个例子:数学方法构建哈夫曼树构建方法描述例子第一步:先找出权值最小的两个结点第二步以这两个结点为叶子,构建一个二叉树,并且把这两个结点去除,再找出权值最小的两个结点第三步:重复以上步骤,直到只剩下最后一个结点为止用c/c++语言实现哈夫曼树哈夫曼树编码的实现  什么是哈夫曼编码&n...
哈夫曼树(C语言)
奋斗的龙猫的博客
04-28 4822
/* 1、定义一个结构体，表示一个节点。其中，这个结构体有4个成员变量，分别 表示是这个节点的权值，父节点及左右子节点的下标 2、定义一个整形数组，用于存放各个节点的权值 3、定义一个整形数组，用于存放哈夫曼编码，当然也可以定义一个整形数组来 存放哈夫曼编码 构建哈夫曼树： 1、给这个哈夫曼树创建一个结构体数组，其中分配的空间是2 * n - 1，因为我们都 知道哈夫曼树的性质有一个是:给定n个叶子节点，那么由这n个叶子节点构成 的哈夫曼树一共含有2 * n - 1个节点 2、前面n个用于存放n个叶子
哈夫曼树（HuffmanTree）的C语言实现
weixin_55582076的博客
05-27 415
最近在学习哈夫曼树相关的内容，相关的代码贴到下面。哈夫曼树不唯一，仅供参考。
哈夫曼树（C语言实现）
m0_70853628的博客
10-23 777
如图，从根节点A到叶子结点H的路径就是A->C->G->H。将树中的结点赋予一个有某种意义的数值。从某一结点到另一结点路过的边的条数。2.什么是路径长度？
构造哈夫曼树 c语言数据结构
05-31
哈夫曼树是一种特殊的二叉树，它的每个叶子节点都对应一个字符，并且每个字符的权值（即出现频率）越高，它在哈夫曼树中距离根节点越近。构造哈夫曼树的基本思路是：首先将所有字符按照权值从小到大排序，然后选取权值最小的两个字符，将它们作为左右子节点构造一棵二叉树，它的根节点的权值为两个子节点的权值之和。接着将新的二叉树插入到原来的字符集合中，再次排序，重复以上步骤，直到只剩下一棵二叉树，即为所求的哈夫曼树。 以下是C语言实现哈夫曼树的代码： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct node { char ch; int freq; struct node* left; struct node* right; } Node; typedef struct list { Node* node; struct list* next; } List; List* create_list(char ch, int freq) { List* list = (List*) malloc(sizeof(List)); list->node = (Node*) malloc(sizeof(Node)); list->node->ch = ch; list->node->freq = freq; list->node->left = NULL; list->node->right = NULL; list->next = NULL; return list; } List* add_list(List* list, char ch, int freq) { if (list == NULL) { return create_list(ch, freq); } List* tmp = list; while (tmp->next != NULL) { tmp = tmp->next; } tmp->next = create_list(ch, freq); return list; } List* remove_list(List* list, List* node) { if (list == node) { list = list->next; free(node->node); free(node); return list; } List* tmp = list; while (tmp->next != node) { tmp = tmp->next; } tmp->next = node->next; free(node->node); free(node); return list; } Node* create_huffman_tree(List* list) { while (list->next != NULL) { List* node1 = list; List* node2 = list->next; list = remove_list(list, node1); list = remove_list(list, node2); Node* node = (Node*) malloc(sizeof(Node)); node->ch = '\0'; node->freq = node1->node->freq + node2->node->freq; node->left = node1->node; node->right = node2->node; list = add_list(list, '\0', node->freq); list->node = node; } return list->node; } void print_huffman_tree(Node* node) { if (node == NULL) { return; } printf("%c:%d\n", node->ch, node->freq); print_huffman_tree(node->left); print_huffman_tree(node->right); } int main() { List* list = NULL; list = add_list(list, 'a', 5); list = add_list(list, 'b', 9); list = add_list(list, 'c', 12); list = add_list(list, 'd', 13); list = add_list(list, 'e', 16); list = add_list(list, 'f', 45); Node* node = create_huffman_tree(list); print_huffman_tree(node); return 0; } ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

SecureCode

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

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

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

打赏作者

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

抵扣说明：

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

余额充值