哈夫曼树+C怪谈

最新推荐文章于 2024-07-23 05:58:04 发布
最新推荐文章于 2024-07-23 05:58:04 发布
阅读量390 收藏
点赞数
分类专栏： Data Structure 文章标签： c语言 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_37287822/article/details/78221140
版权

哈夫曼树

之所以想谈谈哈夫曼树，觉得这玩意还是挺好玩的。它在某些应用中能达到最优处理，这一点就能够吹牛B一大会了。

首先呢，什么是哈夫曼树，讲道理，它就是一颗二叉树，平凡的二叉树怎么无故带个名字呢，可见它并不平凡，它是一种带权路径长度最短的二叉树，也叫做最优二叉树。

值得啰嗦的几个概念

路径长度

从树中一个结点到另一个结点之间的分支构成两个结点之间的路径，路径的分支数叫做路径的长度。

树的路径长度

树的路径长度就是从树根到每一结点的路径长度之和。

带权路径长度

树的带权路径长度记为WPL= (W1*L1+W2*L2+W3*L3+…+Wn*Ln),

N个权值Wi(i=1,2,…n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径

长度为Li(i=1,2,…n)。可以证明哈夫曼树的WPL是最小的。

构造哈夫曼树的方法

  • 先把有权值的叶子结点按照从小到大的顺序排列成一个有序序列。
  • 取头两个最小权值的结点作为新结点N1的两个子结点，注意相对较小的是左孩子。
  • 将N1替换两个相对较小的值，插入序列中，保持从小到大排列。
  • 重复步骤2.直到排序结束。

哈夫曼编码

赫赫，这个是必须要说的，但是很简单，哈夫曼大叔是这样规定的:

左分支代表0；

右分支代表1；

然后对要表示的数据进行01二进制编码。用01串来对其进行编码，压缩程度是相当可观的。与此同时，又是如此的简单。

哈夫曼实现

不能免俗，代码还是要有的。不然直到原理，没办法和实际进行结合也是不行的。

  • HFT.H
#ifndef HFT_H
#define HFT_H
#define MAXBIT      100
#define MAXVALUE  10000
#define MAXLEAF     30
#define MAXNODE    MAXLEAF*2 -1
typedef struct 
{
    int bit[MAXBIT];
    int start;
} HCodeType;        /* 编码结构体 */
typedef struct
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    int value;
} HNodeType;        /* 结点结构体 */

void HuffmanTree (HNodeType HuffNode[MAXNODE],  int n);
void decodeing(char string[],HNodeType Buf[],int Num);
#endif // !HFT_H
  • HFT.C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "HFT.h"

/*-------------------

*--------------------*/

/* 构造一颗哈夫曼树 */
void HuffmanTree (HNodeType HuffNode[MAXNODE],  int n)
{ 
    /* i、j： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，
        x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/
    int i, j, m1, m2, x1, x2;
    /* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */
    for (i=0; i<2*n-1; i++)
    {
        HuffNode[i].weight = 0;//权值 
        HuffNode[i].parent =-1;
        HuffNode[i].lchild =-1;
        HuffNode[i].rchild =-1;
        HuffNode[i].value=i; //实际值，可根据情况替换为字母  
    } /* end for */

    /* 输入 n 个叶子结点的权值 */
    for (i=0; i<n; i++)
    {
        printf ("Please input weight of leaf node %d: \n", i);
        scanf ("%d", &HuffNode[i].weight);
    } /* end for */

    /* 循环构造 Huffman 树 */
    for (i=0; i<n-1; i++)
    {
        m1=m2=MAXVALUE;     /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */
        x1=x2=0;
        /* 找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 */
        for (j=0; j<n+i; j++)
        {
            if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
            {
                m2=m1; 
                x2=x1; 
                m1=HuffNode[j].weight;
                x1=j;
            }
            else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
            {
                m2=HuffNode[j].weight;
                x2=j;
            }
        } /* end for */
            /* 设置找到的两个子结点 x1、x2 的父结点信息 */
        HuffNode[x1].parent  = n+i;
        HuffNode[x2].parent  = n+i;
        HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n+i].lchild = x1;
        HuffNode[n+i].rchild = x2;

        printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
        printf ("\n");
    } 
} /* end HuffmanTree */

//解码 
void decodeing(char string[],HNodeType Buf[],int Num)
{
  int i,tmp=0,code[1024];
  int m=2*Num-1;
  char *nump;
  char num[1024];
  for(i=0;i<strlen(string);i++)
  {
   if(string[i]=='0')
  num[i]=0;        
  else
  num[i]=1;                    
  } 
  i=0;
  nump=&num[0];

 while(nump<(&num[strlen(string)]))
 {tmp=m-1;
  while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
  {

   if(*nump==0)
   {
     tmp=Buf[tmp].lchild ;          
   } 
   else tmp=Buf[tmp].rchild;
   nump++;   
  } 
  printf("%d",Buf[tmp].value);                                  
 }
}
  • MAIN的实现
int main(void)
{

    HNodeType HuffNode[MAXNODE];            /* 定义一个结点结构体数组 */
    HCodeType HuffCode[MAXLEAF],  cd;       /* 定义一个编码结构体数组， 同时定义一个临时变量来存放求解编码时的信息 */
    int i, j, c, p, n;
    char pp[100];
    printf ("Please input n:\n");
    scanf ("%d", &n);
    HuffmanTree (HuffNode, n);


    for (i=0; i < n; i++)
    {
        cd.start = n-1;
        c = i;
        p = HuffNode[c].parent;
        while (p != -1)   /* 父结点存在 */
        {
            if (HuffNode[p].lchild == c)
                cd.bit[cd.start] = 0;
            else
                cd.bit[cd.start] = 1;
            cd.start--;        /* 求编码的低一位 */
            c=p;                    
            p=HuffNode[c].parent;    /* 设置下一循环条件 */
        } /* end while */

        /* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
        for (j=cd.start+1; j<n; j++)
        { HuffCode[i].bit[j] = cd.bit[j];}
        HuffCode[i].start = cd.start;
    } /* end for */

    /* 输出已保存好的所有存在编码的哈夫曼编码 */
    for (i=0; i<n; i++)
    {
        printf ("%d 's Huffman code is: ", i);
        for (j=HuffCode[i].start+1; j < n; j++)
        {
            printf ("%d", HuffCode[i].bit[j]);
        }
        printf(" start:%d",HuffCode[i].start);

        printf ("\n");

    }
    printf("Decoding?Please Enter code:\n");
    scanf("%s",&pp);
    decodeing(pp,HuffNode,n);
    getchar();
    getchar();
    return 0;
}

好了，对于哈夫曼叔叔的这个套路就先聊到这里啦。下期再见~

豆破苍琼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈夫曼树c语言实现
05-06
本例用c语言实现数据结构课程中的哈夫曼树，结构清晰，已编译通过
哈夫曼树(C版)
mm_3_by的博客
07-26 753
概念： 哈夫曼（Huffman）树（最优二叉树）：带权路径长度最小 （1.）结点的权：赋予叶子结点有意义的值 （2.）结点的路径长度：从根节点到当前结点的边的个数 （3.）带权路径=结点的权值*路径长度  （4.）二叉树的带权路径长度：所有叶子节点的带权路径长度之和 构建： 局部最优 先找权值最小的，一次找两个，从下往上建树，并放回森林；左子女最小，右子女次小；重复上面步骤，直至森...
c 霍夫曼树不完整
04-20
霍夫曼树不完整代码，实现字母权重，获取霍夫曼编码
C语言编码哈夫曼树
06-24
#include #include #include #include using namespace std; # define MaxN 100//初始设定的最大结点数 # define MaxC 1000//最大编码长度 # define ImpossibleWeight 10000//结点不可能达到的权值 # define n 26//字符集的个数 //-----------哈夫曼树的结点结构类型定义----------- typedef struct //定义哈夫曼树各结点 { int weight;//权值 int parent;//双亲结点下标 int lchild;//左孩子结点下标 int rchild;//右孩子结点下标 }HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树 typedef char**HuffmanCode;//动态分配数组存储哈夫曼编码表 //-------全局变量-------- HuffmanTree HT; HuffmanCode HC; int *w;//权值数组 //const int n=26;//字符集的个数 char *info;//字符值数组 int flag=0;//初始化标记 //********************************************************************** //初始化函数 //函数功能： 从终端读入字符集大小n , 以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中 //函数参数： //向量HT的前n个分量表示叶子结点，最后一个分量表示根结点，各字符的编码长度不等，所以按实际长度动态分配空间 void Select(HuffmanTree t,int i,int &s1,int &s2) { //s1为最小的两个值中序号最小的那个 int j; int k=ImpossibleWeight;//k的初值为不可能达到的最大权值 for(j=1;j<=i;j++) { if(t[j].weight<k&&t[j].parent==0) {k=t[j].weight; s1=j;} } t[s1].parent=1; k=ImpossibleWeight; for(j=1;j<=i;j++) { if(t[j].weight0），构造哈夫曼树HT，并求出n个字符的哈弗曼编码HC { int i,m,c,s1,s2,start,f; HuffmanTree p; char* cd; if(num<=1) return; m=2*num-1;//m为结点数，一棵有n个叶子结点的哈夫曼树共有2n-1个结点，可以存储在一个大小为2n-1的一维数组中 HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号单元未用 //--------初始化哈弗曼树------- for(p=HT+1,i=1;iweight=*w; p->parent=0; p->lchild=0; p->rchild=0; } for(i=num+1;iweight=0; p->parent=0; p->lchild=0; p->rchild=0; } //--------建哈夫曼树------------- for(i=num+1;i<=m;i++) { Select(HT,i-1,s1,s2);//在HT[1...i-1]选择parent为0且weight最小的两个结点，其序号分别为s1和s2 HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1; HT[i].rchild=s2;//左孩子权值小，右孩子权值大 HT[i].weight=HT[s1].weight+HT[s2].weight; } //-------从叶子到根逆向求每个字符的哈弗曼编码-------- HC=(HuffmanCode)malloc((num+1)*sizeof(char *));//指针数组:分配n个字符编码的头指针向量 cd=(char*)malloc(n*sizeof(char*));//分配求编码的工作空间 cd[n-1]='\0';//编码结束符 for(i=1;i<=n;i++)//逐个字符求哈弗曼编码 { start=n-1;//编码结束符位置 for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到跟逆向求哈弗曼编码 if(HT[f].lchild==c) cd[--start]='0';//判断是左孩子还是右孩子(左为0右为1) else cd[--start]='1'; HC[i]=(char*)malloc((num-start)*sizeof(char*));//按所需长度分配空间 int j,h; strcpy(HC[i],&cd[start]); } free(cd); } //****************初始化函数****************** void Initialization() { flag=1;//标记为已初始化 int i; w=(int*)malloc(n*sizeof(int));//为26个字符权值分配空间 info=(char*)malloc(n*sizeof(char));//为26个字符分配空间 ifstream infile("ABC.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i>info[i]; infile>>w[i]; } infile.close(); cout<<"读入字符成功！"<<endl; HuffmanCoding(HT,HC,w,n); //------------打印编码----------- cout<<"依次显示各个字符的值,权值或频度,编码如下"<<endl; cout<<"字符"<<setw(6)<<"权值"<<setw(11)<<"编码"<<endl; for(i=0;i<n;i++) { cout<<setw(3)<<info[i]; cout<<setw(6)<<w[i]<<setw(12)<<HC[i+1]<<endl; } //---------将建好的哈夫曼树写入文件------------ cout<<"下面将哈夫曼树写入文件"<<endl; ofstream outfile("hfmTree.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i<n;i++,w++) { outfile<<info[i]<<" "; outfile<<w[i]<<" "; outfile<<HC[i+1]<<" "; } outfile.close(); cout<<"已经将字符与对应的权值，编码写入根目录下文件hfmTree.txt"<<endl; } //*****************输入待编码字符函数************************* void Input() { char string[100]; ofstream outfile("ToBeTran.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } cout<<"请输入你想要编码的字符串(字符个数应小于100),以#结束"<>string; for(int i=0;string[i]!='\0';i++) { if(string[i]=='\0') break; outfile<<string[i]; } cout<<"获取报文成功"<<endl; outfile.close(); cout<<"------"<<"已经将报文存入根目录下的ToBeTran.txt文件"<<endl; } //******************编码函数**************** void Encoding() { int i,j; char*string; string=(char*)malloc(MaxN*sizeof(char)); cout<<"下面对根目录下的ToBeTran.txt文件中的字符进行编码"<<endl; ifstream infile("ToBeTran.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;i>string[i]; } for(i=0;i<100;i++) if(string[i]!='#') cout<<string[i]; else break; infile.close(); ofstream outfile("CodeFile.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;string[i]!='#';i++) { for(j=0;j<n;j++) { if(string[i]==info[j]) outfile<<HC[j+1]; } } outfile<<'#'; outfile.close(); free(string); cout<<"编码完成------"; cout<<"编码已写入根目录下的文件CodeFile.txt中"<<endl; } //******************译码函数**************** void Decoding() { int j=0,i; char *code; code=(char*)malloc(MaxC*sizeof(char)); char*string; string=(char*)malloc(MaxN*sizeof(char)); cout<<"下面对根目录下的CodeFile.txt文件中的代码进行译码"<<endl; ifstream infile("CodeFile.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for( i=0;i>code[i]; if(code[i]!='#') { cout<<code[i]; } else break; } infile.close(); int m=2*n-1; for(i=0;code[i-1]!='#';i++) { if(HT[m].lchild==0) { string[j]=info[m-1]; j++; m=2*n-1; i--; } else if(code[i]=='1') m=HT[m].rchild; else if(code[i]=='0') m=HT[m].lchild; } string[j]='#'; ofstream outfile("TextFile.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } cout<<"的译码为------"<<endl; for( i=0;string[i]!='#';i++) { outfile<<string[i]; cout<<string[i]; } outfile<<'#'; outfile.close(); cout<<"------译码完成------"<<endl; cout<<"译码结果已写入根目录下的文件TextFile.txt中"<<endl; free(code); free(string); } //*************打印编码函数**************** void Code_printing() { int i; char *code; code=(char*)malloc(MaxC*sizeof(char)); cout<<"下面打印根目录下文件CodeFile.txt中的编码"<<endl; ifstream infile("CodeFile.txt",ios::in); if(!infile) { cerr<<"打开失败"<<endl; exit(1); } for( i=0;i>code[i]; if(code[i]!='#') cout<<code[i]; else break; } infile.close(); cout<<endl; ofstream outfile("CodePrin.txt",ios::out); if(!outfile) { cerr<<"打开失败"<<endl; exit(1); } for(i=0;code[i]!='#';i++) { outfile<<code[i]; } outfile.close(); free(code); cout<<"------打印结束------"<<endl; cout<<"该字符形式的编码文件已写入文件CodePrin.txt中"<<endl; } //*************打印哈夫曼树函数**************** int numb=0; void coprint(HuffmanTree start,HuffmanTree HT) //start=ht+26这是一个递归算法 { if(start!=HT) { ofstream outfile("TreePrint.txt",ios::out); if(!outfile) { cerr<<"打开失败"<rchild,HT); //递归先序遍历 cout<<setw(5*numb)<weight<rchild==0) cout<<info[start-HT-1]<<endl; outfile<weight; coprint(HT+start->lchild,HT); numb--; outfile.close(); } } void Tree_printing(HuffmanTree HT,int num) { HuffmanTree p; p=HT+2*num-1; //p=HT+26 cout<<"下面打印赫夫曼树"<<endl; coprint(p,HT); //p=HT+26 cout<<"打印工作结束"<<endl; } //*************主函数************************** int main() { char choice; do{ cout<<"************哈弗曼编/译码器系统***************"<<endl; cout<<"请选择您所需功能："<<endl; cout<<":初始化哈弗曼树"<<endl; cout<<":输入待编码字符串"<<endl; cout<<":利用已建好的哈夫曼树进行编码"<<endl; cout<<":利用已建好的哈夫曼树进行译码"<<endl; cout<<":打印代码文件"<<endl; cout<<":打印哈夫曼树"<<endl; cout<<":退出"<<endl; if(flag==0) { cout<<"请先初始化哈夫曼树,输入I"<<endl; cout<<""<>choice; switch(choice) { case 'I':Initialization();break; case 'W':Input();break; case 'E':Encoding();break; case 'D':Decoding();break; case 'P':Code_printing();break; case 'T':Tree_printing(HT,n);break; case 'Q':;break; default:cout<<"输入的命令出错，请重新输入！"<<endl; } }while(choice!='Q'); free(w); free(info); free(HT); free(HC); system("pause"); return 0; }
哈夫曼树与哈夫曼编码
Y_23k_bug的专栏
07-26 5857
在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN) 树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如 JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结
数据结构课设报告+哈夫曼编译器+C语言+源码.doc.pdf
11-24
数据结构课设报告+哈夫曼编译器+C语言+源码.doc.pdf
哈夫曼树+心得.pdf
07-06
。。。
哈夫曼树的c语言实现
02-03
### 哈夫曼树的C语言实现 #### 一、引言 本文将详细介绍如何在C语言中实现哈夫曼树（又称最优二叉树），包括构建过程、哈夫曼编码的生成以及如何对输入的字符串进行编码。哈夫曼树是一种带权路径长度最短的二叉树，...
数据结构课设报告+哈夫曼编译器+C语言+源码.docx
09-30
数据结构课设报告+哈夫曼编译器+C语言+源码.docx
哈夫曼树c语言编写
08-30
哈夫曼树构造 输出
数据结构——哈夫曼树的实现以及编码（C语言实现）
热门推荐
欢迎来到Gorit的博客
11-29 5万+
1、问题描述       利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。构造哈夫曼树时，首先将由n个字 符形成的n个叶子结点存放到数组HuffNode的前n个分量中，然后根据哈夫曼方法的基本思想，不断将两个较小的子树合并为一个 较大的子树，每次构成的新子树的根结点顺序放到HuffNode数组中的前n个分量的后面。        通俗的来讲，哈弗曼树就是一种广...
哈夫曼树编码与译码(完整C/C++实现代码)
菜鸡逆袭的博客
07-02 3万+
哈夫曼编码的设计与应用 问题需求分析 用哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码(有时也称为霍夫曼编码)。 霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树...
（完整版C语言代码）哈夫曼树的构造
qq_41025769的博客
04-09 1598
图：最终构成的哈夫曼树 //哈夫曼树的构造 #include <stdio.h> #include <stdlib.h> #define MinSize -1000 typedef struct HTNode *HuffmanTree; struct HTNode{ int Weight; HuffmanTree Left; HuffmanTree Right; }; typedef HuffmanTree ElementType; typedef struct HeapNo.
数据结构-2-哈夫曼树与哈夫曼编码 原理详解
loadingsong的专栏
09-01 7040
哈夫曼树与哈夫曼编码   首先，介绍下什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结点的路径长度 为叶结点的层数）。树的带权路径长度记为WPL= (W1*L1+W2*L2+W3*L3+...+Wn*Ln) ，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点
C/C++语言：简单哈夫曼树
攻城狮的博客
01-27 707
树的一些概念： 路径：从树中任一结点到达另一结点的通路称为路径 路径长度：路径上所经过的边的个数称为路径长度 结点权值：树结点带有某种意义的数值称为权值 结点的带权路径长度：从树根结点到树中某结点的路径长度乘以该结点的权值的值 树的带权路径长度：所有叶结点的带权路径长度之和 哈夫曼树：树的带权路径长度最小的二叉树（这里我们默认是二叉哈夫曼树），也称为最优树 哈夫曼树的一些应用：求哈弗
哈夫曼树 C语言实现
WTF
12-06 2万+
1、基本概念 a、路径和路径长度 若在一棵树中存在着一个结点序列 k1，k2，……，kj， 使得 ki 是 ki+1 的双亲（1 从 k1 到 kj 所经过的分支数称为这两点之间的路径长度，它等于路径上的结点数减1. b、结点的权和带权路径长度 在许多应用中，常常将树中的结点赋予一个有着某种意义的实数，我们称此实数为该结点的权，(如下面一个树中的蓝色数字表示结点
c语言构造哈夫曼树-哈夫曼编码
快乐的孙悟空的博客
12-05 2万+
构造哈夫曼树 首先，我们需要了解哈夫曼树是什么： 一．相关知识点 路径： 路径是指从一个节点到另一个节点的分支序列。 路径长度： 指从一个节点到另一个结点所经过的分支数目。 ，从根节点到a的分支数目是2， 数的路径长度： 树中所有结点的路径长度之和为树的路径长度PL 如图pl为10 节点的权： 给树的每个结点赋予一个具有某种实际意义的实数，我们称该实数为这个结点的权 带权路径长度： 从树根...
哈夫曼树C语言实现
liuxiongfeng22的博客
11-30 2407
//小顶堆 typedef struct{     HTree a[MAXSIZE];     int size; }S; int prarent(int i){         return i/2;     } int right(int i){         return 2*i+1;     } int left(int i){         return 2*i;     } //插...
C语言 | Leetcode C语言题解之第278题第一个错误的版本
最新发布
m0_59237910的博客
07-23 469
C语言 | Leetcode C语言题解之第278题第一个错误的版本
构造哈夫曼树 代码 C语言
11-22
以下是用C语言实现构造哈夫曼树的代码示例： ```c #include #include // 定义哈夫曼树结点的结构体 typedef struct Node { int weight; struct Node *left; struct Node *right; } Node; // 创建一个新的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值