一起talk C栗子吧（第四十一回：C语言实例--哈夫曼树）

最新推荐文章于 2022-04-23 21:53:58 发布
最新推荐文章于 2022-04-23 21:53:58 发布
阅读量1.5k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 一起Talk C栗子吧 文章标签： c语言 哈夫曼树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/talk_8/article/details/47947317
本文详细介绍了哈夫曼树的概念及其构建过程，并通过实例演示如何计算哈夫曼树的带权路径长度，展示了其在数据压缩中的优势。


各位看官们，大家好，上一回中咱们说的是遍历二叉树的例子，这一回咱们说的例子是：哈夫曼树。闲话

休提，言归正转。让我们一起talk C栗子吧！


哈夫曼树也叫赫夫曼树，其实它们都是从英语翻译过来的，只是音译的不同而已，大家不需要对它咬文嚼

字。它的英文原文是：Huffman.这是一个数学家的姓氏，因为它发明了哈夫曼编码，为了纪念他所做贡

献，所以用它的姓氏命名。


在说哈夫曼树前，我们说一下树的路径和权。树中结点的路径是指从树中根结点到某个结点的距离，如果

为这个路径加上一个权值，那么结点的带权路径就是路径长度与权值的乘积。树的带权路径是指树中所有

结点的带权路径之和。这么说，大家可能觉得很抽象，我们举个例子来说明：



在上面的图中，我们依次列出个结点的路径：

  • Path-A：2 ==>从根结点g到A的路径为4，权值设定为2,带权路径为4×2=8；
  • Path-B：3 ==>从根结点g到B的路径为4，权值设定为3,带权路径为4×3=12；
  • Path-C：5 ==>从根结点g到C的路径为5，权值设定为5,带权路径为5×5=25；
  • Path-D：7 ==>从根结点g到D的路径为2，权值设定为7,带权路径为2×7=14；
  • Path-E：4 ==>从根结点g到E的路径为5，权值设定为4,带权路径为5×4=20；
  • Path-F：8 ==>从根结点g到F的路径为2，权值设定为8,带权路径为2×8=16；
  • Path-G：1 ==>从根结点g到G的路径为4，权值设定为1,带权路径为4×1=5；
  • Path-H：6 ==>从根结点g到H的路径为3，权值设定为6,带权路径为3×6=18；
  • 这棵树的带权路径等于：Path-A+Path-B+..Path-H=8+12+25+14+20+16+5+18=118


在计算的过程中，小写字母所在的结点是合成的结点，因此不统计它们的权值。或者把它们理解成构造哈

夫曼树的辅助结点，就像现实生活中的临时工，那么其它的结点就是正式工了。哈哈！


通过这个例子，我想大家已经明白了树的带权路径。接下来我们说说什么是哈夫曼树。哈夫曼树是一种带

权路径长度最小的二叉树。创建哈夫曼树的思路为：把二叉树中权值最小的两个结点当作左右孩子，其中

左边孩子的权值更加小一些；接着把这两个孩子的权值相加当作它们父亲的权值；然后把这两个孩子从二

叉树中删除，同时把它们的父亲放到二叉树中；反复执行这个过程，直到二叉树中只剩下最后一个结点为

止，这个时候的二叉树就是一棵哈夫曼树。看官们，这个思路可能抽象一些，我们顺着这个思路来说说如

何创建哈夫曼树，下面是具体的实现步骤：


  • 1.从终端或者文件中读取结点的值，把这些存放在一个数组中；
  • 2.把数组中的元素，依据结点的权值从小到大进行排序；
  • 3.从数组中获取元素，获取数组中的第一个元素就可以；
  • 4.判断获取的值，如果值是‘X’，那么表示二叉树中没有结点，返回步骤3.如果不是‘X’，进入步骤5；
  • 5.给结点分配存储空间，并且把步骤3中获取元素的值当作该结点的值；
  • 6.重复步骤3到5,获取第二个元素；
  • 7.把数组中前两个元素删除，并且合成为一个新元素，新元素的权值为这两个元素权值之和；被删除的这
  • 两个元素是新元素的左孩子和右孩子，其中权值小的是左孩子；
  • 8.把步骤7中的新元素放到数组中第一个位置，其它元素向前移动一位；
  • 9.反复执行步骤2到8,直到数组中只剩下一个元素为止。

看官们，正文中就不写代码了，详细的代码放到了我的资源中，大家可以点击这里下载使用。在代码中把

元素的值和权值都放到了一个数组中。数组排序的过程封装成了一个函数，同时还把步骤7和8中生成父结

点的过程封装成了一个函数。这样可以提高代码的复用性。另外，大家还记得我们在前面章回中创建普通

二叉树的过程吧，我建议大家对比一下创建普通二叉树的过程和创建哈夫曼树的过程。你会发现创建普通

二叉树是从树的根结点开始一直到叶子结点，专业上叫作自顶向下；而哈夫曼树正好与它相反：从叶子结

点开始一直到根结点，专业上叫作自底向上。下面是生成生成Huffman树的过程，我在每行末尾添加了相

关的注释，方便大家理解 。

The inputting value of node are as following

A  2 |B  3 |C  5 |D  7 |E  4 |F  8 |G  1 |H  6 |

Create a Huffman Tree

//下面是创建Huffman树过程中，结点序列的变化，其中X表示空结点，其权值为0

G  1 |A  2 |B  3 |E  4 |C  5 |H  6 |D  7 |F  8 | //第一次排序后结点序列

a  3 |B  3 |E  4 |C  5 |H  6 |D  7 |F  8 |X  0 | //第一次合并后的结点序列

a  3 |B  3 |E  4 |C  5 |H  6 |D  7 |F  8 |X  0 | //第二次排序后结点序列

b  6 |E  4 |C  5 |H  6 |D  7 |F  8 |X  0 |X  0 | //第二次合并后的结点序列

E  4 |C  5 |b  6 |H  6 |D  7 |F  8 |X  0 |X  0 | //第三次排序后结点序列

c  9 |b  6 |H  6 |D  7 |F  8 |X  0 |X  0 |X  0 | //第三次合并后的结点序列

b  6 |H  6 |D  7 |F  8 |c  9 |X  0 |X  0 |X  0 | //第三次排序后结点序列

d 12 |D  7 |F  8 |c  9 |X  0 |X  0 |X  0 |X  0 | //第三次合并后的结点序列

D  7 |F  8 |c  9 |d 12 |X  0 |X  0 |X  0 |X  0 | //第四次排序后结点序列

e 15 |c  9 |d 12 |X  0 |X  0 |X  0 |X  0 |X  0 | //第四次合并后的结点序列

c  9 |d 12 |e 15 |X  0 |X  0 |X  0 |X  0 |X  0 | //第五次排序后结点序列

f 21 |e 15 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 | //第五次合并后的结点序列

e 15 |f 21 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 | //第六次排序后结点序列

g 36 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 | //第六次合并后的结点序列

g 36 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 |X  0 | //第七次只排序，因为只有一个结点


Traverse a Huffman Tree

g e D F f c E C d b a G A B H   //前序遍历Huffman树的结果

Destroy a Huffman Tree

下面是刚才图中哪棵树的哈夫曼树，我们一起来计算一下这棵Huffman树的权值：


  • Path-A：2 ==>从根结点g到A的路径为5，权值设定为2,带权路径为5×2=10；
  • Path-B：3 ==>从根结点g到B的路径为4，权值设定为3,带权路径为4×3=12；
  • Path-C：5 ==>从根结点g到C的路径为3，权值设定为5,带权路径为3×5=15；
  • Path-D：7 ==>从根结点g到D的路径为2，权值设定为7,带权路径为2×7=14；
  • Path-E：4 ==>从根结点g到E的路径为3，权值设定为4,带权路径为3×4=12；
  • Path-F：8 ==>从根结点g到F的路径为2，权值设定为8,带权路径为2×8=16；
  • Path-G：1 ==>从根结点g到G的路径为5，权值设定为1,带权路径为5×1=5；
  • Path-H：6 ==>从根结点g到H的路径为3，权值设定为6,带权路径为3×6=18；
  • 这棵树的带权路径等于：Path-A+Path-B+..Path-H=10+12+15+14+12+16+5+18=102


对比一下两棵树的带权路径就能发现Huffman树的带权路径要比普通树的小。因此，我们说哈夫曼树是带

权路径最小的二叉树。


各位看官，关于哈夫曼树的例子咱们就说到这里。欲知后面还有什么例子，且听下回分解。



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; }
2020-11-17实验哈夫曼树
qq_40824748的博客
11-17 1624
实验三 哈夫曼树。实验目的及要求：1、要求学生掌握树和二叉树的基本概念；2、要求学生深刻理解二叉树的性质和存储结构，熟练掌握二叉树的遍历算法；3、认识哈夫曼树、哈夫曼编码的作用和意义；4、能够建立一个哈夫曼树，并输出哈夫曼编码，正确调试程序。本题要求实现一个创建哈夫曼树的函数，根据输入的n个结点的权值，创建一棵哈夫曼树。例如输入5 2 3 5 7 8，其中第一个数值5，表示5个结点，2 3 5 7 8分别表示这5个结点的权值，中间用空格分开，则该函数应该输出5(2,3),10(5,5),15(7,8),25
哈夫曼编码C++实现
dwj6336736的博客
10-15 4471
#include <stdio.h> #include <limits.h> #include <string.h> #include <stdlib.h> #define N 6 typedef struct huffNode { unsigned int weight; //权重 unsigned int lchild,rchild,parent
哈夫曼树的实现
口中冰的博客
12-12 402
核心算法如下PhuffmanTree createHuffmanTree(int * a, int n) { PhuffmanTree p[n]; PhuffmanTree ptr, root = NULL; int i, j; for (i = 0; i < n; i++) { ptr = (PhuffmanTree)malloc(sizeof(huffmanTreeN
哈夫曼树及实现
小菜鸡
02-23 332
霍夫曼树java实现
完整word版-C语言-哈夫曼树编码器和译码器.doc
11-24
哈夫曼树编码器和译码器在C语言中的实现 哈夫曼树是一种特殊的二叉树，它广泛应用于数据压缩、编码和译码等领域。哈夫曼树编码器和译码器是哈夫曼树的重要应用之一，它们可以将原始数据压缩到极小的尺寸，提高数据...
  数据结构-C语言-哈夫曼树
05-04
C语言实现的哈夫曼树
C语言-基于哈夫曼树的数据压缩算法.zip
11-15
哈夫曼编码是一种高效的数据压缩算法，它利用了字符出现频率的不同来构建特殊的二叉树——哈夫曼树（Huffman Tree），进而为每个字符分配一个唯一的二进制编码，频繁出现的字符会得到较短的编码，不常出现的字符则...
数据结构-哈夫曼树-实验-C语言实现
最新发布
11-08
在C语言实现哈夫曼树的过程中，首先需要建立一个优先队列（通常是小根堆）来组织权值信息，然后通过不断合并权值最小的两个节点来构造哈夫曼树，每合并一次都会生成一个新的内部节点，这个新节点的权值是两个被合并...
哈夫曼编码C语言实现-利用哈夫曼编码进行通信可以大大提高信道的利用率
01-03
根据哈夫曼编码的原理，编写一个程序，在用户输入结点权值的基础上求哈夫曼编码。 从键盘输入若干字符及每个字符出现的频率，将字符出现的频率作为结点的权值，建立哈夫曼树，求出各字符的哈夫曼编码。要求： 1．...
从文件读取字符串建立哈夫曼树并进行哈夫曼编码
12-04
利用文件中的字符资源建立哈夫曼树，利用建立的哈夫曼树对给定的字符串进行编码。资源中含有可执行的源代码以及实验报告。
哈夫曼树的构造过程
lmh的博客
07-25 3万+
今天做题的时候，遇到了一个关于哈夫曼树的题，由于一直不是很明白哈夫曼树的构造过程，所以找了很多资料都不是特别清楚的，直到我遇到了这篇文章，哈哈，在此分享给大家哦！ 注意：哈夫曼树并不唯一，但带权路径长度一定是相同的。 （1）8个结点的权值大小如下： （2）从19，21，2，3，6，7，10，32中选择两个权小结点。选中2，3。同时算出这两个结点的和5。
最优二叉树——哈夫曼树
long_yu2的专栏
04-28 1273
一：什么是最优二叉树？ 从我个人理解来说，最优二叉树就是从已给出的目标带权结点(单独的结点) 经过一种方式的组合形成一棵树.使树的权值最小. 最优二叉树是带权路径长度最短的二叉树。根据结点的个数，权值的不同，最优二叉树的形状也各不相同。它们的共同点是：带权值的结点都是叶子结点。权值越小的结点，其到根结点的路径越长 官方定义： 在权为wl，w2，…，wn的n个叶子所构成的所有二叉树中，...
赫夫曼编码
08-21 262
#include #include using namespace std; struct tree{     int weight;//权值     int rchild;//右孩子     int lchild;//左孩子     int parent;//父亲 }; void g(vector &t) {     int size = t.s
给定一篇英文文章，建立哈夫曼树进行压缩存贮，并且实现解码功能
The best wjh的博客
10-31 923
#include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct node //哈夫曼树的每个节点 { int bol,num; //bo1为0或1，num为每个字符或字母的个数 char ch; //存字母或字符 struct node* lchild; struct node* rchild; struct node* next; // 构
哈夫曼树 C语言实现
WTF
12-06 2万+
1、基本概念 a、路径和路径长度 若在一棵树中存在着一个结点序列 k1，k2，……，kj， 使得 ki 是 ki+1 的双亲（1 从 k1 到 kj 所经过的分支数称为这两点之间的路径长度，它等于路径上的结点数减1. b、结点的权和带权路径长度 在许多应用中，常常将树中的结点赋予一个有着某种意义的实数，我们称此实数为该结点的权，(如下面一个树中的蓝色数字表示结点
哈夫曼树编码的实现+图解（含全部代码）
Initial_Mind的博客
04-23 11万+
只能说太用心了
哈夫曼树以及哈夫曼编码的构造步骤
热门推荐
LDF-Dicky的博客
06-11 12万+
注意：哈夫曼树并不唯一，但带权路径长度一定是相同的。（1）8个结点的权值大小如下：（2）从19，21，2，3，6，7，10，32中选择两个权小结点。选中2，3。同时算出这两个结点的和5。（3）从19，21，6，7，10，32，5中选出两个权小结点。选中5，6。同时计算出它们的和11。（4）从19，21，7，10，32，11中选出两个权小结点。选中7，10。同时计算出它们的和17。（BTW：这时选出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

talk_8

真诚赞赏，手有余香

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

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

打赏作者

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

抵扣说明：

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

余额充值