赫夫曼树建立c语言源程序编译结果详细解释,使用C语言详解霍夫曼树数据结构...

最新推荐文章于 2022-09-18 14:55:59 发布
最新推荐文章于 2022-09-18 14:55:59 发布
阅读量381 收藏
点赞数
文章标签： 赫夫曼树建立c语言源程序编译结果详细解释

1、基本概念

a、路径和路径长度

若在一棵树中存在着一个结点序列 k1，k2，……，kj， 使得 ki是ki+1 的双亲(1<=i

从 k1 到 kj 所经过的分支数称为这两点之间的路径长度，它等于路径上的结点数减1.

b、结点的权和带权路径长度

在许多应用中，常常将树中的结点赋予一个有着某种意义的实数，我们称此实数为该结点的权，(如下面一个树中的蓝色数字表示结点的权)

结点的带权路径长度规定为从树根结点到该结点之间的路径长度与该结点上权的乘积。

c、树的带权路径长度

树的带权路径长度定义为树中所有叶子结点的带权路径长度之和，公式为：

1a8ed99cc70783805a61eaa9e8e6177f.png

其中，n表示叶子结点的数目，wi 和 li 分别表示叶子结点 ki 的权值和树根结点到 ki 之间的路径长度。

如下图中树的带权路径长度 WPL = 9 x 2 + 12 x 2 + 15 x 2 + 6 x 3 + 3 x 4 + 5 x 4  =  122

d、哈夫曼树

哈夫曼树又称最优二叉树。它是 n 个带权叶子结点构成的所有二叉树中，带权路径长度 WPL 最小的二叉树。

如下图为一哈夫曼树示意图。

ac819c37deaf35c5c5bb016a3e85389d.png

2、构造哈夫曼树

假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为：

(1) 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)；

(2) 在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；

(3)从森林中删除选取的两棵树，并将新树加入森林；

(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。

如：对 下图中的六个带权叶子结点来构造一棵哈夫曼树，步骤如下：

fa3c73b73b77cd8db8dcd0c5bc41ee02.png

注意：为了使得到的哈夫曼树的结构尽量唯一，通常规定生成的哈夫曼树中每个结点的左子树根结点的权小于等于右子树根结点的权。

具体算法如下：

//2、根据数组 a 中 n 个权值建立一棵哈夫曼树，返回树根指针

struct BTreeNode* CreateHuffman(ElemType a[], int n)

{

int i, j;

struct BTreeNode **b, *q;

b = malloc(n*sizeof(struct BTreeNode));

for (i = 0; i < n; i++) //初始化b指针数组，使每个指针元素指向a数组中对应的元素结点

{

b[i] = malloc(sizeof(struct BTreeNode));

b[i]->data = a[i];

b[i]->left = b[i]->right = NULL;

}

for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树

{

//k1表示森林中具有最小权值的树根结点的下标，k2为次最小的下标

int k1 = -1, k2;

for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树，k2指向第二棵

{

if (b[j] != NULL && k1 == -1)

{

k1 = j;

continue;

}

if (b[j] != NULL)

{

k2 = j;

break;

}

}

for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小

{

if (b[j] != NULL)

{

if (b[j]->data < b[k1]->data)

{

k2 = k1;

k1 = j;

}

else if (b[j]->data < b[k2]->data)

k2 = j;

}

}

//由最小权值树和次最小权值树建立一棵新树，q指向树根结点

q = malloc(sizeof(struct BTreeNode));

q->data = b[k1]->data + b[k2]->data;

q->left = b[k1];

q->right = b[k2];

b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置

b[k2] = NULL;//k2位置为空

}

free(b); //删除动态建立的数组b

return q; //返回整个哈夫曼树的树根指针

}

3、哈夫曼编码

在电报通信中，电文是以二进制的0、1序列传送的，每个字符对应一个二进制编码，为了缩短电文的总长度，采用不等长编码方式，构造哈夫曼树，

将每个字符的出现频率作为字符结点的权值赋予叶子结点，每个分支结点的左右分支分别用0和1编码，从树根结点到每个叶子结点的路径上

所经分支的0、1编码序列等于该叶子结点的二进制编码。如上文所示的哈夫曼编码如下：

0ef56bb0bd7e17c5e2ddc207dc4f6f48.png

a 的编码为：00

b 的编码为：01

c 的编码为：100

d 的编码为：1010

e 的编码为：1011

f 的编码为：11

4、哈夫曼树的操作运算

以上文的哈夫曼树作为具体实例，用详细的程序展示哈夫曼树的操作运算

#include

#include

typedef int ElemType;

struct BTreeNode

{

ElemType data;

struct BTreeNode* left;

struct BTreeNode* right;

};

//1、输出二叉树，可在前序遍历的基础上修改。采用广义表格式，元素类型为int

void PrintBTree_int(struct BTreeNode* BT)

{

if (BT != NULL)

{

printf("%d", BT->data); //输出根结点的值

if (BT->left != NULL || BT->right != NULL)

{

printf("(");

PrintBTree_int(BT->left); //输出左子树

if (BT->right != NULL)

printf(",");

PrintBTree_int(BT->right); //输出右子树

printf(")");

}

}

}

//2、根据数组 a 中 n 个权值建立一棵哈夫曼树，返回树根指针

struct BTreeNode* CreateHuffman(ElemType a[], int n)

{

int i, j;

struct BTreeNode **b, *q;

b = malloc(n*sizeof(struct BTreeNode));

for (i = 0; i < n; i++) //初始化b指针数组，使每个指针元素指向a数组中对应的元素结点

{

b[i] = malloc(sizeof(struct BTreeNode));

b[i]->data = a[i];

b[i]->left = b[i]->right = NULL;

}

for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树

{

//k1表示森林中具有最小权值的树根结点的下标，k2为次最小的下标

int k1 = -1, k2;

for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树，k2指向第二棵

{

if (b[j] != NULL && k1 == -1)

{

k1 = j;

continue;

}

if (b[j] != NULL)

{

k2 = j;

break;

}

}

for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小

{

if (b[j] != NULL)

{

if (b[j]->data < b[k1]->data)

{

k2 = k1;

k1 = j;

}

else if (b[j]->data < b[k2]->data)

k2 = j;

}

}

//由最小权值树和次最小权值树建立一棵新树，q指向树根结点

q = malloc(sizeof(struct BTreeNode));

q->data = b[k1]->data + b[k2]->data;

q->left = b[k1];

q->right = b[k2];

b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置

b[k2] = NULL;//k2位置为空

}

free(b); //删除动态建立的数组b

return q; //返回整个哈夫曼树的树根指针

}

//3、求哈夫曼树的带权路径长度

ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始为0

{

if (FBT == NULL) //空树返回0

return 0;

else

{

if (FBT->left == NULL && FBT->right == NULL)//访问到叶子结点

return FBT->data * len;

else //访问到非叶子结点，进行递归调用，返回左右子树的带权路径长度之和，len递增

return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);

}

}

//4、哈夫曼编码(可以根据哈夫曼树带权路径长度的算法基础上进行修改)

void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值为0

{

static int a[10];//定义静态数组a，保存每个叶子的编码，数组长度至少是树深度减一

if (FBT != NULL)//访问到叶子结点时输出其保存在数组a中的0和1序列编码

{

if (FBT->left == NULL && FBT->right == NULL)

{

int i;

printf("结点权值为%d的编码：", FBT->data);

for (i = 0; i < len; i++)

printf("%d", a[i]);

printf("\n");

}

else//访问到非叶子结点时分别向左右子树递归调用，并把分支上的0、1编码保存到数组a

{ //的对应元素中，向下深入一层时len值增1

a[len] = 0;

HuffManCoding(FBT->left, len + 1);

a[len] = 1;

HuffManCoding(FBT->right, len + 1);

}

}

}

//主函数

void main()

{

int n, i;

ElemType* a;

struct BTreeNode* fbt;

printf("从键盘输入待构造的哈夫曼树中带权叶子结点数n：");

while(1)

{

scanf("%d", &n);

if (n > 1)

break;

else

printf("重输n值：");

}

a = malloc(n*sizeof(ElemType));

printf("从键盘输入%d个整数作为权值：", n);

for (i = 0; i < n; i++)

scanf(" %d", &a[i]);

fbt = CreateHuffman(a, n);

printf("广义表形式的哈夫曼树：");

PrintBTree_int(fbt);

printf("\n");

printf("哈夫曼树的带权路径长度：");

printf("%d\n", WeightPathLength(fbt, 0));

printf("树中每个叶子结点的哈夫曼编码：\n");

HuffManCoding(fbt, 0);

}

运行结果：

514bed12aa1a6857856055b9ce9e5e4b.png

下面来看一道ACM题目

题目描述：

哈夫曼树，第一行输入一个数n，表示叶结点的个数。需要用这些叶结点生成哈夫曼树，根据哈夫曼树的概念，这些结点有权值，即weight，题目需要输出所有结点的值与权值的乘积之和。

输入：

输入有多组数据。

每组第一行输入一个数n，接着输入n个叶节点(叶节点权值不超过100，2<=n<=1000)。

输出：

输出权值。

样例输入：

5

1 2 2 5 9

样例输出：

37

ac代码

链表构建哈夫曼树(插入排序)

#include

#include

#define max 1001

struct htree

{

int weight;

struct htree *lchild;

struct htree *rchild;

struct htree *next;

};

void addNode(struct htree *, struct htree *);

struct htree* createHfmtree(int *, int);

int getWpl(struct htree *, int);

int main()

{

int w[max];

int i, n, wpl;

struct htree *ht;

while(scanf("%d", &n) != EOF)

{

for(i = 0; i < n; i ++)

{

scanf("%d", &w[i]);

}

ht = createHfmtree(w, n);

wpl = getWpl(ht, 0);

printf("%d\n", wpl);

}

return 0;

}

struct htree* createHfmtree(int *w, int n)

{

int i;

struct htree *head, *pl, *pr, *proot;

head = (struct htree *)malloc(sizeof(struct htree));

head->next = NULL;

for(i = 0; i < n; i ++)

{

struct htree *pnode = malloc(sizeof(struct htree));

pnode->weight = *(w + i);

pnode->lchild = pnode->rchild = pnode->next = NULL;

addNode(head, pnode);

}

while(head->next)

{

if(head->next->next == NULL)

break;

pl = head->next;

pr = pl->next;

head->next = pr->next;

proot = (struct htree *)malloc(sizeof(struct htree));

proot->weight = pl->weight + pr->weight;

proot->lchild = pl;

proot->rchild = pr;

addNode(head, proot);

}

return head->next;

}

void addNode(struct htree *head, struct htree *pnode)

{

struct htree *t = head;

while(t->next && t->next->weight < pnode->weight)

t = t->next;

pnode->next = t->next;

t->next = pnode;

}

int getWpl(struct htree *ht, int level)

{

if(ht == NULL)

return 0;

if(!ht->lchild && !ht->rchild)

{

return ht->weight * level;

}

return getWpl(ht->lchild, level + 1) + getWpl(ht->rchild, level + 1);

}

杜不知道
关注
数据结构之---C语言实现哈夫曼树和编码
杨鑫newlife的专栏
07-03 1万+
数据结构之---C语言实现哈夫曼树和编码
哈夫曼树c语言编写
08-30
哈夫曼树构造 输出
用C语言实现哈夫曼树
whoami_2011的专栏
12-19 2370
//哈夫曼树C语言实现 #include #include typedef struct HuffmanNode { char letter;//存储的字符，叶节点为字母，非叶节点为# struct HuffmanNode *parent;//父亲结点 int code;//如果为父亲结点的左孩子，则为0，右孩子为1 }HuffmanNode; typ
C语言：详解哈夫曼树（赫夫曼树、最优树）
weixin_50711484的博客
09-18 1585
给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
哈夫曼树的简单实现（C语言）
Lucky Home
04-08 7943
书上二叉树后面就到哈夫曼树了，过一阵就要整这个的实验课了，趁着这次机会赶快自学下，不知道写的如何，希望大家多多指正吧。 哈夫曼树 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 基本术语 哈夫曼树又称为最优树. 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为
<数据结构与算法>霍夫曼树与霍夫曼编码（C语言描述）
WSG的博客--盛年不重来,一日难再晨.及时当勉励,岁月不待人.
08-29 1401
哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。 哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL=(W1*L1+W2*L2+W3*L3+...+Wn*Ln)，N个权
数据结构之赫夫曼树（C语言）
x_trusher的博客
12-21 947
赫夫曼树，又称最优二叉树，是一类带权值路径长度最短的树，有着广泛的应用。 代码： /* 数据结构之赫夫曼树及求最优带权路径长度（带权路径长度：WPL） 思路： 自底向上，优先合并权值小的结点。合并后，双亲结点权值设为两子结点之和，忽略被合并的结点， 如此重复至所有结点都归入一棵树 */ #include&lt;stdio.h&gt; #include&lt;s...
赫夫曼树的c语言实现
xutian_curry的博客
04-03 1570
一颗有n个叶子结点的赫夫曼树共有2*n-1，可以储存在一个一维数组中。编码时候需要从叶子到根的路径。故对每一个结点而言，需要知道双亲的信息和孩子的信息。故利用以下存储结构typedef struct { int weight; int parent,lchild,rchild; }HTNode,*HuffmanTree;//动态分配数组储存赫夫曼树赫夫曼树的构造算法：1.每次从树的...
赫夫曼树的实现数据结构实验报告.doc
05-04
【赫夫曼树的实现与数据结构实验报告】 在计算机科学中，赫夫曼树（Huffman Tree）是一种特殊的二叉树，常用于数据压缩。赫夫曼编码是一种高效的无损数据压缩方法，通过构建赫夫曼树来为数据符号分配最短的二进制...
赫夫曼树的构建及赫夫曼编码（C语言源代码，代码中含详细注释）
10-31
C语言实现赫夫曼树的构建及赫夫曼编码的源代码，帮助你掌握Huffman编码的算法实现。赫夫曼树的建立，及实现其编码，和数据结构教材上的算法同步。基于C语言，模拟赫夫曼树的构造并对之进行编码。代码简洁，附报告书...
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; }
huffman函数
08-04
huffman压缩编码 function CODE =huffman(p) error(nargchk(1,1,nargin)); if (ndims(p)~=2) ||(min(size(p))>1)||~isreal(p)||~isnumeric(p) error('P must be a real numeric vector.'); end global CODE CODE=cell(length(p),1); if length(p)>1 p=p/sum(p); s=reduce(p); makecode(s,[]); else CODE={'1'}; end
【Dev-c++】C语言数据结构实验——赫夫曼树的建立和应用
m0_52474147的博客
07-25 903
1、从键盘输入一串电文字符，统计字符种类及出现的频率建立赫夫曼树。1、认真阅读程序，将未完成的代码补全（红色部分）。3、保存和截图程序的运行结果，并结合程序进行分析。2、上机调试，并运行程序。......
哈夫曼树带权路径长度c语言,【哈夫曼树】求结点的哈夫曼的带权路径长度
weixin_39532421的博客
05-22 3271
本文用C++采用顺序存储实现求哈夫曼树(即最小生成树)的带权路径长度努力下面来了解一下哈夫曼树的构造以及如何求带权路径长度：哈夫曼树为带权路径长度最小的树哈夫曼树哈夫曼树的顺序存储【问题描述】已知输入一串正整数，正整数之间用空格键分开，请建立一个哈夫曼树，以输入的数字为叶节点，求这棵哈夫曼树的带权路径长度。【输入形式】首先输入正整数的个数，然后接下来为接下来的正整数，正整数个数不超过10个【输出形...
c语言 赫夫曼树和编码（哈夫曼树和编码）
jiangjun_feng的博客
05-11 412
运行结果正确 感觉最难的是树的合并 #include<stdio.h> #include <stdlib.h> #include <string.h> #include<malloc.h> //构造哈夫曼树 typedef struct { int val; int parent,left,right; }node,*tree; //构造哈夫曼编码 typedef struct{ int weight; int code[10]; }code_nod
赫夫曼树和赫夫曼编码（C语言版）
qq2977078774的博客
12-07 4406
赫夫曼树和赫夫曼编码（C语言版）一.赫夫曼树（一）赫夫曼树的定义二.赫夫曼编码（一）赫夫曼编码的定义及表示方法三.C语言编写（一）代码设计思路（二）源代码总览（三）部分源代码函数分析四.小结 一.赫夫曼树 （一）赫夫曼树的定义 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度（WPL）最短的树，权值较大的结点离根较近。 二.赫夫曼编码 （一）赫夫曼编码的定义及表示方法 将赫夫曼树权值的
[C/C++] 构造最优二叉树－赫夫曼(哈夫曼、Huffman)树算法实现
11-16 7986
一、基本概念1、赫夫曼（Huffman）树又称最优二叉树或最优搜索树，是一种带权路径长度最短的二叉树。在许多应用中，常常赋给树中结点一个有某种意义的实数，称此实数为该结点的权。从树根结点到该结点之间的路径长度与该结点上权的乘积称为结点的带权路径长度(WPL)，树中所有叶子结点的带权路径长度之和称为该树的带权路径长度，通常记为：2、两结点间的路径：从一结点到另一结点所经过的结点序列;路径长度：从根结点到相应结点路径上的分支数目;树的路径长度：从根到每一结点的路径长度之和。3、深度为k，结点数为n的二叉树，当且
赫夫曼树建立c语言源程序编译结果详细解释,c语言构建哈夫曼树(附运行结果图)[本站推荐]...
weixin_29209805的博客
05-18 448
#include#include#includeint m,s1,s2;typedef struct {unsigned int weight;unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; //动态分配数组存储哈夫曼树typedef char *HuffmanCode; //动态分配数组存储哈夫曼编码表void Select(Huf...
C语言数据结构：树与二叉树转换及遍历详解
本章主要探讨的是树与二叉树在C语言数据结构中的相互转换以及相关的概念和应用。首先，我们回顾了树的基本定义和术语，树是一种由n个结点构成的有限集，其中包含一个特殊的根节点，其他非空结点形成互不相交的子树。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值