• 5星
4.44MB qq_44781688 2021-07-03 19:09:34
• ## 霍夫曼树编码解码 霍夫曼树

1KB u010811449 2013-08-14 11:27:10
• ## Huff_code_霍夫曼树编码_源码 霍夫曼树编码

15.04MB weixin_42683392 2021-10-04 04:37:29
• ## 霍夫曼树编码与译码 霍夫曼树

//创建霍夫曼树 { int s1 , s2 ; if ( n 1 ) return ; int m = 2 * n - 1 ; for ( int i = n + 1 ; i m ; ++ i ) { select ( hf , i - 1 , s1 , s2 ) ; hf [ s1 ] . parent = i ; hf...
#include<iostream>
#include<stdlib.h>
#include<cstring>
using namespace std;
typedef struct hftree{
int might;
int parent,lch,rch;
char data;
}*tree,node;
typedef char** treecode;
int length;//字符串长度；
void chushi(tree &hf,int n)//初始话
{
hf=new node[2*n];
for(int i=1;i<=2*n-1;i++)
{
hf[i].data='\0';
hf[i].might=0;
hf[i].lch=0;
hf[i].rch=0;
hf[i].parent=0;
}
}
void select(tree T,int n,int &s1,int &s2)//找出权值最小的两个;
{
int k,m;
k=m=1000000;
for(int j=1;j<=n;j++)
{
if(m>T[j].might&&T[j].parent==0)
{
m=T[j].might;
s1=j;
}
}
for(int i=1;i<=n;i++)
{
if(i!=s1&&k>T[i].might&&T[i].parent==0)
{
k=T[i].might;
s2=i;
}
}
}
void hftree(tree &hf,int n)//创建霍夫曼树
{
int s1,s2;
if(n<=1) return;
int m=2*n-1;
for(int i=n+1;i<=m;++i)
{
select(hf,i-1,s1,s2);
hf[s1].parent=i;
hf[s2].parent=i;
if(s1<=s2){
hf[i].lch=s1;
hf[i].rch=s2;
}
else{
hf[i].lch=s2;
hf[i].rch=s1;
}
hf[i].might=hf[s1].might+hf[s2].might;
}
}
void codetree(tree hf,treecode &hc,int n)//获取字符的编码值
{
int m,p;
hc=new char*[n+1]; //指针数组；
char *cd=new char[n];	//存放编码
cd[n-1]='\0';
for(int i=1;i<=n;i++)
{
int start=n-1;
m=i;
p=hf[i].parent;
while(p!=0)
{
--start;
if(hf[p].lch==m)
{
cd[start]='0';
}
else
cd[start]='1';
m=p;
p=hf[p].parent;
}
hc[i]=new char[n-start];
strcpy(hc[i],&cd[start]);
}
delete []cd;
}
void input(tree &hf,int &n,char *date)//输入字符串
{
char *a=date;
int length_1;
int num[256]={0};
int b[256];
int c[256];
cout<<"输入字符串：";
getchar();
gets(a);
length_1=strlen(a);
for(int i=0;i<length_1;i++)
{
num[(int)a[i]]++;//统计每个字符的权值
}
n=0;
for(int i=0;i<256;i++)
{
if(num[i]!=0)
{
b[n]=num[i];
c[n]=(char)i;
++n;
}
}
hf=new node[2*n];
for(int i=1;i<=2*n-1;i++)
{
hf[i].data='\0';
hf[i].might=0;
hf[i].lch=0;
hf[i].rch=0;
hf[i].parent=0;
}
for(int i=1;i<=n;i++)
{
hf[i].might=b[i-1];
hf[i].data=c[i-1];
}
}
int weizhi(tree hf,char *q,int n) //获取字符在树中的位置
{
char *date=q;
for(int j=1;j<=n;++j)
{
if(*date==hf[j].data)
return j;
}
}
void bianmachar(tree hf,char *q,treecode &result,int n)//对字符串编码
{
char *date=q;
char *cd;
int m,p;
result=new char * [length+1];//存放每个字符的编码值;
cd=new char[n];
cd[n-1]='\0';
for(int i=0;i<length;++i)
{
m=weizhi(hf,&date[i],n);//获取每个字符在树中的位置
int start=n-1;
p=hf[m].parent;
while(p!=0)
{
--start;
if(hf[p].lch==m)
{
cd[start]='0';
}
else
cd[start]='1';
m=p;
p=hf[p].parent;
}
result[i+1]=new char[n-start];
strcpy(result[i+1],&cd[start]);
}
delete cd;
}
void chu(tree hf,treecode hc,treecode result,int n)//输出编码
{
int m=2*n-1;
cout<<"每个字符在树中的位置"<<endl;
for(int i=1;i<=m;i++)
{
cout<<i<<" "<<hf[i].data<<" "<<hf[i].might<<" "<<hf[i].parent<<" "<<hf[i].lch<<" "<<hf[i].rch<<endl;
}
cout<<"每个字符的编码"<<endl;
for(int i=1;i<=n;i++)
{
cout<<hf[i].data<<" "<<hc[i]<<endl;
}
cout<<"对字符串的编码:";
for(int j=1;j<=length;j++)
{
cout<<result[j];
}
}
void input_(tree &hf,int &n) //输入每个字符和对应的权值
{
cout<<"输入字符和对应的权值"<<endl;
for(int i=1;i<=n;i++)
{
cin>>hf[i].data;
cin>>hf[i].might;
}
}
void Decodehf(tree hf,char *m,int n)//译码
{
char*date=m;//编码字符串
int LL=strlen(date);//编码字符串长度
char data[100];//解码字符串；
int p=2*n-1;//获取根节点的位置;
int j=0;//头指针
for(int i=0;i<length;i++)
{
if(date[i]=='0')
p=hf[p].lch;
else if(date[i]=='1')
p=hf[p].rch;
if(hf[p].lch==0&&hf[p].rch==0)
{
data[j]=hf[p].data;
p=2*n-1;
++j;
}
}
cout<<"对应编码:";
for(int k=0;k<j;k++)
{
cout<<data[k];
}
cout<<endl;
}
void Xmb()//界面
{	cout<<"\t\t\t------------------------------------------"<<endl;
cout<<"\t\t\t|************霍夫曼编码译码**************|"<<endl;
cout<<"\t\t\t|----------------------------------------|"<<endl;
cout<<"\t\t\t|********1.对字符串进行编码译码**********|"<<endl;
cout<<"\t\t\t|----------------------------------------|"<<endl;
cout<<"\t\t\t|********2.输入字符的权值编码译码********|"<<endl;
cout<<"\t\t\t------------------------------------------"<<endl;
}
int main()
{
char a;
char date_1[100];//输入字符串统计权值
char date_2[100];//需要要编码的字符串
char date_3[100];//存储译码的字符串
tree hf; //hfm树
treecode hc;//存储每个字符的译码
treecode result;//存放译码的字符串
int n;//拥有权值的字符个数
while(1)
{
Xmb();
cout<<"输入相应命令:";
cin>>a;
switch(a)
{
case '1':
input(hf,n,date_1);
hftree(hf,n);//创建霍夫曼树
codetree(hf,hc,n);//每个字符的编码
cout<<"输入需要编码的字符串:";
gets(date_2);
length=strlen(date_2);
bianmachar(hf,date_2,result,n);//字符串的编码
chu(hf,hc,result,n);
cout<<endl;
cout<<"输入需要译码的编码：" ;
gets(date_3);
Decodehf(hf,date_3,n);
break;
case '2':
cout<<"输入字符个数:";
cin>>n;
chushi(hf,n);//对霍夫曼树初始化
input_(hf,n);//输入字符和对应的权值
hftree(hf,n);
codetree(hf,hc,n);
cout<<"输入需要编码的字符串:";
getchar();
gets(date_2);
length=strlen(date_2);
bianmachar(hf,date_2,result,n);
chu(hf,hc,result,n);
cout<<endl;
cout<<"输入需要译码的编码：" ;
gets(date_3);
Decodehf(hf,date_3,n);
break;
case '0':
exit(0);
}
}

}



展开全文
weixin_43937576 2019-05-24 20:21:25
• 148KB leavemyleave 2021-09-16 22:49:24
• ## 用C++实现霍夫曼树编码 霍夫曼编码

5星
6KB sxyzfseu 2009-01-20 14:10:30
• 903KB suifenggyy 2011-06-03 13:41:11
• ## 霍夫曼树 编码 recursion tree delete output input

根据小慧JJ的课件完成，用数组存储二叉树，Fun_encrypt_leaf()由叶子开始至根部编码，这个存储编码串时从尾部开始存储，对编码好的字符串进行拷贝时正好倒置过来；fun_encrypt_recursion()从根部开始递归到叶子进行...
根据小慧JJ的课件完成，用数组存储二叉树，Fun_encrypt_leaf()由叶子开始至根部编码，这个存储编码串时从尾部开始存储，对编码好的字符串进行拷贝时正好倒置
过来；fun_encrypt_recursion()从根部开始递归到叶子进行编码；fun_encrypt_onrecurent()非递归无栈从根部到叶子进行编码。思想都很强大，我是码农— —
bbb……

#include<一坨头文件>
using namespace std;
#define new Pzjay
const int MAX=1<<25;
const int length=50;//假设每个字母编码后最长50位
typedef char** hufferman_code;
char *word;
struct node
{
int value;
};
void select(node *HT,int n,int &s1,int &s2)
{
int i;
int MIN_1=MAX,MIN_2=MAX;//分别记录最小的跟次小的,初始很大
//sort(HT,HT+n);
for(i=1;i<=n;++i)
if(MIN_1>HT[i].value)
{
MIN_1=HT[i].value;
s1=i;
}
for(i=1;i<=n;++i)
if(MIN_2>HT[i].value && i!=s1)
{
MIN_2=HT[i].value;
s2=i;
}
}
void initialize_tree(node *HT,int *w,int n)//初始化霍夫曼树,加密，构造hufferman树
{
int m,i;
m=n*2-1;
if(n<=1)
return;
for(i=1;i<=n;++i)
{
HT[i].value=w[i];
}
for(i=n+1;i<=m;++i)
printf("下面是构建hufferman树的过程/n/n");
int s1,s2;//记录每次取出的两个频率最小的结点
for(i=n+1;i<=m;++i)
{
select(HT,i-1,s1,s2);//得到节点最小的两个节点的序号,s1<=s2的
//cout<<"s1= "<<s1<<" s2= "<<s2<<endl;
HT[i].Lch=s1;
HT[i].Rch=s2;
HT[i].value=HT[s1].value+HT[s2].value;
}
}
void encrypt_leaf(node *HT,hufferman_code &HC,int n)//开始编码加密---从叶子到根逆向编码
{
char *cd;
int start,c,f;
cd=Pzjay char[n];
cd[n-1]='/0';
for(int i=1;i<=n;++i)
{
start=n-1;
{
if(HT[f].Lch==c)
cd[--start]='0';
else
cd[--start]='1';
}
HC[i]=Pzjay char [n-start];//第i个字符的编码长度为n-start
strcpy(HC[i],cd+start);
//printf("中间 %c: %s/n",word[i],cd);/
}
delete cd;
}
int cd_len=0;//递归函数所用到的全局变量
void encrypt_recursion(int i,char *cd,node *HT,hufferman_code &HC)//递归编码,传递进节点编号i；从根节点开始编码
{
cd[cd_len++]='0';
cd[cd_len++]='1';//右儿子
if(0==HT[i].Rch && 0==HT[i].Lch)//编码完成，到达叶子节点
{
//cout<<"i= "<<i<<" ";
HC[i]=Pzjay char[cd_len+1];
cd[cd_len]='/0';//strcpy函数识别用
//cout<<word[i]<<" "<<cd<<endl;
strcpy(HC[i],cd);
--cd_len;
}
else
{
if(HT[i].Lch!=0)//还有左儿子，遍历之
{
encrypt_recursion(HT[i].Lch,cd,HT,HC);
}
if(HT[i].Rch!=0)//还有右儿子，回退一个，遍历之
{
--cd_len;
encrypt_recursion(HT[i].Rch,cd,HT,HC);
}
--cd_len;//
}
}
void encrypt_onrecurent(node *HT,hufferman_code &HC,int n)//非递归无栈编码
{
char *cd;
cd=Pzjay char [n];
cd_len=0;//全局变量
int p=2*n-1,i;
for(i=1;i<=2*n-1;++i)
HT[i].value=0;//此时value数据域作用是标记，为0时向左儿子，1向右儿子，2回溯到父亲那
//初始是向左儿子遍历——先序遍历
while(p)//初始p=2*n-1，处于根节点
{
if(0==HT[p].value)//向左走
{
HT[p].value=1;//左儿子遍历完毕，下面就是遍历右儿子，提前标记之
if(HT[p].Lch!=0)//左儿子的左儿子……
{
p=HT[p].Lch;
cd[cd_len++]='0';
}
else if(0==HT[p].Rch)
{
HC[p]=Pzjay char [cd_len+1];
cd[cd_len]='/0';
strcpy(HC[p],cd);
//printf("中间 %c: %s/n",word[p],cd);//
}
}
else if(HT[p].value==1)//向右走value写成了Rch
{
HT[p].value=2;//左右儿子都遍历过了，下面就是回到父亲那
if(HT[p].Rch!=0)//右儿子有后代
{
p=HT[p].Rch;
cd[cd_len++]='1';
}
}
else
{
HT[p].value=0;//回到父节点，下面是左儿子
--cd_len;
}
}
delete cd;
}
void printf_hufferman(hufferman_code HC,int n)
{
for(int i=1;i<=n;++i)
{
printf("%c: ",word[i]);
printf("%s/n",HC[i]);
}
}
int main()
{
int *frequency;//保存字符出现频率---扩大100倍
int i,n;
node *hufferman_tree;
hufferman_code HC;

scanf("%d",&n);//输入字符个数
getchar();

HC=Pzjay char* [n+5];
word=Pzjay char [n+5];
frequency=Pzjay int [n+5];//预留缓冲空间

for(i=1;i<=n;++i)
{
scanf("%c %d",word+i,frequency+i);//输入各个字符及相应的出现频率
getchar();
}
hufferman_tree=Pzjay node[2*n];//先进行地址空间申请，才能传递进构造树的函数
initialize_tree(hufferman_tree,frequency,n);//初始化

//for(int i=2*n-1;i>0;--i)//查看建好的树

encrypt_leaf(hufferman_tree,HC,n);//从叶子开始的编码
printf("从叶子开始编码的结果/n");
printf_hufferman(HC,n);//打印编码后的字符

char *cd=Pzjay char[n+5];
encrypt_recursion(2*n-1,cd,hufferman_tree,HC);//递归从根开始编码
printf("从根开始的递归编码的结果/n");
printf_hufferman(HC,n);
delete cd;

encrypt_onrecurent(hufferman_tree,HC,n);//非递归无栈编码
printf("非递归无栈编码的结果/n");
printf_hufferman(HC,n);

return 0;
}
测试数据和编码结果：
Input:
8a 12b 3c 4e 67f 56g 2h 10i 100
Output:

a: 110b: 10100c: 101011e: 111f:  1011g: 101010h: 100i:   0

Input:

5a 1b 2c 3d 4e 5
Output:

a: 010b: 011c: 00d: 10e: 11

Input:

3a 1b 2c 4
Output:

a: 00b: 01c: 1

ps:根据建树实现细节的不同，编码结果可能大同小异，可以无视……可以无视……
展开全文
shifuwawa 2010-04-29 12:25:00
• ## 算法设计与分析--霍夫曼树编码(C++实现) 算法 C++

w2, …, wn}，应用哈夫曼构造最短的不等长编码方案。 Huffman算法： 给定实数w1,w2,···，wt且 w1 （1）连接w1,w2为权的两片树叶，得一分支点，其权为w1+w2 ； （2）在w1+w2, w3+···+wt中...
问题描述：

设需要编码的字符集为{d1, d2, …, dn}，它们出现的频率为{w1, w2, …, wn}，应用哈夫曼树构造最短的不等长编码方案。

Huffman算法：

给定实数w1,w2,···，wt且 w1<=w2<=···<=wt
（1）连接w1,w2为权的两片树叶，得一分支点，其权为w1+w2 ；
（2）在w1+w2, w3+···+wt中选出两个最小的权，连接它们对应的顶点（不一定都是树叶），得分支点及所带的权；
（3）重复（2），直到形成t – 1个分支点，t片树叶为止。

算法实例：

C++代码：

#include<iostream>
#include<string>
using namespace std;

//结点类型
struct element
{
double weight;	//字符出现的概率为实数
char ch;
int lchild, rchild, parent;
};

//在HuffTer中找权值最小的两个结点i1和i2
void Select(element huffTree[], int *a, int *b, int n)
{
int i;
double weight = 0;
for(i = 0; i <n; i++)
{
if(huffTree[i].parent != - 1)		//如果有父结点的，不进行判断
continue;
else
{
if(weight == 0)
{
weight = huffTree[i].weight;
*a = i;
}
else
{
if(huffTree[i].weight < weight)
{
weight = huffTree[i].weight;
*a = i;
}
}
}
}
weight = 0;
for(i = 0; i < n; i++)
{
if(huffTree[i].parent != -1 || (i == *a))
continue;
else
{
if(weight == 0)
{
weight = huffTree[i].weight;
*b = i;
}
else
{
if(huffTree[i].weight  < weight)
{
weight = huffTree[i].weight;
*b = i;
}
}
}
}
int temp;
if(huffTree[*a].lchild < huffTree[*b].lchild)		//避免根结点的左右子树混淆
{
temp = *a;
*a = *b;
*b = temp;
}
}

//建立霍夫曼树
void HuffmanTree(element huffTree[], int w[], char ch[], int n)
{
for(int i = 0; i < 2 * n - 1;i++) //霍夫曼树共有2*n - 1个结点
{
huffTree[i].parent = -1;	//双亲结点
huffTree[i].lchild = -1;	//左孩子结点
huffTree[i].rchild = -1;	//右孩子结点
}
for(int i = 0; i < n; i++)		//构造n棵只含有根结点的二叉树
{
huffTree[i].weight = w[i];	//给哈夫曼树赋权值
huffTree[i].ch = ch[i];		//需要编码的字符
}
for(int k = n; k < 2 * n - 1; k++)//n-1次合并
{
int i1 = 0;
int i2 = 0;
Select(huffTree,&i1,&i2,k);	//在HuffTer中找权值最小的两个结点i1和i2
huffTree[i1].parent = k;	//将i1和i2合并，则i1和i2的双亲是k
huffTree[i2].parent = k;
huffTree[k].weight = huffTree[i1].weight + huffTree[i2].weight;
huffTree[k].lchild = i1;
huffTree[k].rchild = i2;
}
}

//霍夫曼编码
void HuffmanCode(element huffTree[], int n)
{
int i, j,k;
string s = "";
for(i = 0; i < n; i++)	//在数组HuffTree中前n个元素是叶子结点，需要编码
{
s = "";			//编码s初始化为空串
j = i;					//暂存i，不破坏循环变量
while(huffTree[j].parent != -1)	//结点j存在双亲
{
k = huffTree[j].parent;
if(j == huffTree[k].lchild)	//结点j是其双亲的左孩子
{
s = s + "0";
}
else				//结点j是其双亲的右孩子
{
s = s + "1";
}
j = huffTree[j].parent;	//将结点j的双亲赋给j
}
cout<<"字符"<<huffTree[i].ch<<"的编码："<<endl;
for(int i =s.size() - 1; i >= 0; i--)	//将s作为结点i的编码逆序输出
{
cout<<s.at(i)<<" ";
}
cout<<endl;
}
}

int main()
{
const int n = 6;
element huffTree[2 * n];
char ch[] = {'a', 'b', 'c','d','e','f'};
int w[] = {50, 60, 150, 200, 240, 300};
// 构造霍夫曼树
HuffmanTree(huffTree,w,ch,n);
//编码
HuffmanCode(huffTree,n);
system("pause");
return 0;
}

实验结果：


展开全文
wwj_748 2013-05-27 19:29:05
• ## 数据结构--霍夫曼树与霍夫曼编码 霍夫曼树 霍夫曼编码

文章目录最优树的定义如何构造最优树（霍夫曼算法）霍夫曼编码前缀编码总结 最优树的定义 节点的路径长度定义为：从根节点到该节点的路径上分支的数目。 的路径长度定义为：中每个节点的路径长度之和。 的带权...


文章目录
最优树的定义如何构造最优树（霍夫曼算法）霍夫曼编码前缀编码
总结

最优树的定义
节点的路径长度定义为：从根节点到该节点的路径上分支的数目。
树的路径长度定义为：树中每个节点的路径长度之和。
树的带权路径长度定义为：树中所有叶子节点的带权路径长度之和。（叶子节点权值*节点路径长度）
在所有含 n 个叶子结点、并带相同权值的m叉树中，必存在一棵其带权路径长度取最小值的树，称为“最优树”。
如何构造最优树（霍夫曼算法）
根据给定的n个权值

{

w

1

,

w

2

,

.

.

.

,

w

n

}

\{w_1, w_2, ..., w_n\}

，构造n棵二叉树的集合

F

=

{

T

1

,

T

2

,

.

.

.

,

T

n

}

F = \{T_1, T_2, ... , T_n\}

，其中每棵二叉树中均只含一个带权值为

w

i

w_i

的根结点,其左、右子树为空树;在F中选取其根结点的权值为最小的两棵二叉树，分别作为左、右子树构造 一棵新的二叉树，并置这棵新的二叉树根结点的权值为其左、右子树根结点的权值之和;从F中删去这两棵树，同时加入刚生成的新树;重复 (2) 和 (3) 两步，直至 F 中只含一棵树为止。
例如：已知权值

W

=

{

5

,

6

,

2

,

9

,

7

}

W = \{5,6,2,9,7\}

霍夫曼编码
将构成电文的每个不同字符作为叶子结点，其权值为电文中字 符的使用频率或次数，构造哈夫曼树。此哈夫曼树中从根到每个叶子结点都有一条唯一的路径，对路径上各分支约定，左分支标识为“0”码，右标识为“1”码，则从根结点到叶子结点的路径上分支的“0”、“1”码组成的字符串即为该叶子结点的霍夫曼编码。
举例:数据传送中的二进制编码,要传送数据 state, seat, act, tea, cat, set, a, eat，如 何使传送的长度最短?
首先规定二叉树的构造为左走 0，右走 1。
为了保证长度最短，先看字符出现的次数，然后将出现次数当作权，如下所示。

构建霍夫曼树的过程：

霍夫曼编码：

所以有 state 的编码为00111101101，stat的编码为001111011。
前缀编码
若要设计长短不等的编码,则必须是任一个字符的编码都不是另外一个字符编码的前缀,这种编码称做前缀编码。（否则解析时会出现错误）
总结
用n个权值(对应n个叶子结点)构造哈夫曼树，共需要

n

−

1

n-1

次合并，即哈夫曼树中非叶子结点的总数为

n

−

1

n-1

，总结点个数为

2

n

−

1

2n-1

。哈夫曼树中没有度为1的结点，因为非叶子结点都是通过两个结点合并而来。但是，没有度为1的二叉树并不一定是哈夫曼树。用 n 个权值(对应n个叶子结点)构造的哈夫曼树，形态并不是唯一的。哈夫曼编码是能使电文代码总长最短的编码方式。此结论由哈夫曼树是带权路径长度最小的树的特征可得。哈夫曼编码是一种前缀编码，保证其在译码时不会产生歧义。因为，在哈夫曼编码中，每个字符都是叶子结点，而叶子结点不可能从根结点到其他叶子结点的路径上，所以一个字符的哈夫曼编码不可能是另一个字符的哈夫曼编码的前缀。深度为

h

h

的哈夫曼树，其叶子结点的最大编码长度为

h

−

1

h-1

。
展开全文
hjc256 2019-07-08 20:44:37
• ## 霍夫曼树与霍夫曼编码 二叉树

q763562998 2020-03-01 22:27:18
• itworld123 2020-11-18 07:26:50
• ## 数据结构 C语言实现霍夫曼树的编码译码详解 数据结构 霍夫曼树 赫夫曼树 哈夫曼树

qq_43670973 2019-11-11 22:14:13
• ## 学习笔记--霍夫曼树与霍夫曼编码解码 Huffman Tree

ZP_icenow 2018-07-14 11:38:11
• weixin_42295110 2021-08-12 19:10:56
• 4星
3KB lebronobama 2010-10-18 23:55:19
• qq_36607894 2020-05-10 22:22:35
• weixin_43937576 2019-05-21 17:52:06
• ## 霍夫曼树——霍夫曼编码 算法 数据结构 java

Blackoutdragon 2020-01-30 22:06:29
• ## java数据结构课设霍夫曼树与编码 java 数据结构

7KB weixin_46598932 2021-03-08 13:28:16
• 106KB weixin_38669628 2019-08-13 01:26:56
• ## 霍夫曼树和霍夫曼编码原理 编码 原理

sddxqlrjxr 2016-04-10 20:20:59
• yishujixiaoxiao 2019-06-26 09:27:25
• ## 霍夫曼树和霍夫曼编码以及霍夫曼编码的应用 java 数据结构

weixin_44991304 2021-05-23 14:47:20
• ## 数据结构：霍夫曼树与霍夫曼编码（Huffman Tree） 数据结构 霍夫曼树 树结构

weixin_45669613 2020-02-18 21:09:13
• ## 霍夫曼树的构建及霍夫曼编码 c++ 霍夫曼树 数组 链表

glugluwater 2020-11-30 21:43:21
• ## python实现霍夫曼树以及编码 python 二叉树路径 霍夫曼编码 哈夫曼编码 遍历

dreaming__star 2018-11-29 16:49:08
• ## matlab 霍夫曼树的生成与霍夫曼编码 霍夫曼树 霍夫曼编码 matlab

weixin_43222324 2019-05-11 01:36:05

...