算法设计与分析实验报告贪心算法
实验三-贪心算法
for(inti=0;i<s.length();i++){
buf.append(getEachCode(s.substring(i,i+1)));
}
returnbuf.toString();
}
publicString getEachCode(String name){
for(inti=0;i<buffer.length();i++){
if(name.equals(codes[i].name)){
returnhuffstring[i];
}
}
return"";
}
publicvoidgetCode(intn,String[] thecodes,String thebuffer){
importjava.util.Scanner;
classHuffmanCode{
Stringname;
doubleweight;
intlc,rc,pa;
publicHuffmanCode(){
name="";
weight=0;
lc=-1;rc=-1;pa=-1;
}
}
publicclassHuffman1 {
dist[j]=newdist;prev[j]=u;}}}}
(3)运行结果
3、题目三
(1)问题分析
设G=（V，E）是连通带权图，V={1，2，…,n}。构造G的最小生成树的Prim算法的基本思想是：首先置S{1}，然后，只要S是V的真子集，就进行如下的贪心选择：选取满足条件i∈S，j∈V-S，且c[i][j]最小的边，将顶点j添加到S中。这个过程一直进行到S=V时为止。过程中所取到的边恰好构成G的一棵最小生成树。
实验3贪心算法（定稿）
实验3贪心算法（定稿）第一篇：实验3 贪心算法（定稿）《算法设计与分析》实验报告实验3贪心算法姓名学号班级实验日期实验地点一、实验目的1、掌握贪心算法的设计思想。
2、理解最小生成树的相关概念。
二、实验环境1、硬件环境 CPU：酷睿i5 内存：4GB 硬盘：1T2、软件环境操作系统：Windows10 编程环境：jdk 编程语言：Java三、实验内容：在Prim算法与Kruskal算法中任选一种求解最小生成树问题。
1、你选择的是：Prim算法2、数据结构（1）图的数据结构——图结构是研究数据元素之间的多对多的关系。
在这种结构中，任意两个元素之间可能存在关系，即结点之间的关系可以是任意的，图中任意元素之间都可能相关。
图形结构——多个对多个，如（2）树的数据结构——树结构是研究数据元素之间的一对多的关系。
在这种结构中，每个元素对下(层)可以有0个或多个元素相联系，对上(层)只有唯一的一个元素相关，数据元素之间有明显的层次关系。
树形结构——一个对多个，如3、算法伪代码 Prim(G,E,W)输入：连通图G 输出：G的最小生成树T 1.S←{1};T=∅ 2.While V-S ≠∅ do3.从V-S中选择j使得j到S中顶点的边e的权最小；T←T∪{e}4.S←S∪{j}3、算法分析时间复杂度：O(n)空间复杂度：O(n^2)4、关键代码（含注释）package Prim;import java.util.*;publicclass Main { staticintMAXCOST=Integer.MAX_VALUE;staticint Prim(intgraph[][], intn){ /* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */ intlowcost[]=newint[n+1];/* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */ intmst[]=newint[n+1];intmin, minid, sum = 0;/* 默认选择1号节点加入生成树，从2号节点开始初始化*/ for(inti = 2;i<= n;i++){/* 标记1号节点加入生成树 */ mst[1] = 0;/* n个节点至少需要n-1条边构成最小生成树 */ for(inti = 2;i<= n;i++){/* 找满足条件的最小权值边的节点minid */ for(intj = 2;j<= n;j++){/* 输出生成树边的信息:起点，终点，权值 */System.out.printf(“%c1, minid + 'A''A' + 1;intj = chy-'A' + 1;graph[i][j] = cost;graph[j][i] = cost;for(intj = 1;j<= n;j++){ } graph[i][j] = MAXCOST;} } System.out.println(”Total:"+cost);} }5、实验结果（1）输入（2）输出最小生成树的权值为：生成过程：(a)(b)(d)(e)(c)四、实验总结（心得体会、需要注意的问题等）这次实验，使我受益匪浅。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如1元、5元、10元、50元和100元，现在需要支付给客户x元，如何用最少的硬币数完成支付？解决思路：贪心算法可以通过每次选择当前面值最大的硬币来求解。
具体步骤如下：1. 初始化一个空的硬币集合，用于存放选出的硬币。
2. 从面值最大的硬币开始，如果当前硬币的面值小于等于待支付金额，则将该硬币放入集合中，并将待支付金额减去该硬币的面值。
3. 重复步骤2，直到待支付金额为0。
实验过程：以支付金额为36元为例，我们可以通过贪心算法求解最少硬币数。
首先，面值最大的硬币为100元，但36元不足以支付100元硬币，因此我们选择50元硬币。
此时，剩余待支付金额为36-50=-14元。
接下来，面值最大的硬币为50元，但待支付金额为负数，因此我们选择下一个面值最大的硬币，即10元硬币。
此时，剩余待支付金额为-14-10=-24元。
继续选择10元硬币，剩余待支付金额为-24-10=-34元。
再次选择10元硬币，剩余待支付金额为-34-10=-44元。
最后，选择5元硬币，剩余待支付金额为-44-5=-49元。
由于待支付金额已经为负数，我们无法继续选择硬币。
此时，集合中的硬币数为1个50元和3个10元，总共4个硬币。
实验结果：通过贪心算法，我们得到了36元支付所需的最少硬币数为4个。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法贪心算法是一种基于贪心策略的求解问题的方法，该方法在每一步都采取最优的选择，从而最终得到全局最优解。
本实验将介绍贪心算法的概念、特点以及实际应用。
1.贪心算法的概念和特点贪心算法是一种求解问题的策略，它在每一步都做出局部最优选择，以期望最终得到全局最优解。
它不考虑每一步选择的长远影响，而只关注眼前能得到的最大利益。
贪心算法有以下特点：1.1.子问题的最优解能够推导父问题的最优解：贪心算法解决的问题具有最优子结构，即问题的最优解包含其子问题的最优解。
1.2.贪心选择性质：通过选择当前最优解，可以得到局部最优解。
1.3.无后效性：当前选择的最优解不会对以后的选择产生影响。
2.实际应用2.1.背包问题背包问题是一个经典的优化问题，贪心算法可以用于解决背包问题的一种情况，分数背包问题。
在分数背包问题中，物品可以被分割成任意大小，而不仅仅是0和1两种状态，因此可以通过贪心算法求解。
2.2.最小生成树问题最小生成树问题是求解连通带权图的一种最优生成树的问题。
其中，普里姆算法和克鲁斯卡尔算法就是贪心算法的典型应用。
2.3.哈夫曼编码哈夫曼编码是一种用于对信息进行无损压缩的方法，它可以将出现频率较高的字符用较短的二进制编码表示。
贪心算法可以在构建哈夫曼树的过程中选择出现频率最低的两个字符进行合并。
3.贪心算法的设计步骤3.1.理解问题并找到最优解的子结构。
3.2.根据问题特点设计贪心策略。
3.3.利用贪心策略进行求解，并逐步推导得到全局最优解。
3.4.对求得的解进行检验，确保其满足问题的要求。
4.贪心算法的优缺点4.1.优点：贪心算法简单直观，易于实现和理解；对于一些问题，贪心算法可以得到全局最优解。
4.2.缺点：贪心算法无法保证得到问题的全局最优解；贪心策略的选择可能不唯一综上所述，贪心算法是一种基于贪心策略的求解问题的方法，通过每一步的局部最优选择，期望得到全局最优解。
贪心算法具有明显的优点和缺点，在实际应用中可以有效地解决一些问题。
算法设计与分析实验报告
算法设计与分析实验报告算法设计与分析实验报告引言：算法设计与分析是计算机科学中的重要课程，它旨在培养学生解决实际问题的能力。
本次实验旨在通过设计和分析不同类型的算法，加深对算法的理解，并探索其在实际应用中的效果。
一、实验背景算法是解决问题的步骤和方法的描述，是计算机程序的核心。
在本次实验中，我们将重点研究几种经典的算法，包括贪心算法、动态规划算法和分治算法。
通过对这些算法的设计和分析，我们可以更好地理解它们的原理和应用场景。
二、贪心算法贪心算法是一种基于局部最优选择的算法，它每一步都选择当前状态下的最优解，最终得到全局最优解。
在实验中，我们以背包问题为例，通过贪心算法求解背包能够装下的最大价值物品。
我们首先将物品按照单位重量的价值从大到小排序，然后依次将能够装入背包的物品放入，直到背包无法再装下物品为止。
三、动态规划算法动态规划算法是一种通过将问题分解为子问题，并记录子问题的解来求解整体问题的算法。
在实验中，我们以斐波那契数列为例，通过动态规划算法计算斐波那契数列的第n项。
我们定义一个数组来保存已经计算过的斐波那契数列的值，然后通过递推公式将前两项的值相加得到后一项的值，最终得到第n项的值。
四、分治算法分治算法是一种将问题分解为更小的子问题，并通过递归求解子问题的算法。
在实验中，我们以归并排序为例，通过分治算法对一个无序数组进行排序。
我们首先将数组分成两个子数组，然后对子数组进行递归排序，最后将两个有序的子数组合并成一个有序的数组。
五、实验结果与分析通过对以上三种算法的设计和分析，我们得到了以下实验结果。
在贪心算法中，我们发现该算法能够在有限的时间内得到一个近似最优解，但并不能保证一定得到全局最优解。
在动态规划算法中，我们发现该算法能够通过记忆化搜索的方式得到准确的结果，但在问题规模较大时，其时间复杂度较高。
在分治算法中，我们发现该算法能够将问题分解为更小的子问题，并通过递归求解子问题，最终得到整体问题的解。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：07实验项目名称：实验8 贪心算法（一）一、实验题目1.删数问题问题描述：键盘输入一个高精度的正整数N（不超过250 位），去掉其中任意k个数字后剩下的数字按原左右次序将组成一个新的非负整数。
编程对给定的N 和k，寻找一种方案使得剩下的数字组成的新数最小。
若输出前有0则舍去2.区间覆盖问题问题描述：设x1,x2,...xn是实轴上的n个点。
用固定长度为k的闭区间覆盖n个点，至少需要多少个这样的固定长度的闭区间？请你设计一个有效的算法解决此问题。
3.会场安排问题问题描述：假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
设计一个有效的贪心算法进行安排。
（这个问题实际上是著名的图着色问题。
若将每一个活动作为图的一个顶点，不相容活动间用边相连。
使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。
）4.导弹拦截问题问题描述：某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。
但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。
某天，雷达捕捉到敌国的导弹来袭。
由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
给定导弹依次飞来的高度（雷达给出的高度数据是≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
二、实验目的（1）通过实现算法，进一步体会具体问题中的贪心选择性质，从而加强对贪心算法找最优解步骤的理解。
（2）掌握通过迭代求最优的程序实现技巧。
（3）体会将具体问题的原始数据预处理后（特别是以某种次序排序后），常能用贪心求最优解的解决问题方法。
三、实验要求（1）写出题1的最优子结构性质、贪心选择性质及相应的子问题。
（2）给出题1的贪心选择性质的证明。
（3）（选做题）：写出你的算法的贪心选择性质及相应的子问题，并描述算法思想。
算法实验报告贪心
一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。
贪心算法并不保证能获得最优解，但往往能获得较好的近似解。
在许多实际应用中，贪心算法因其简单、高效的特点而被广泛应用。
本实验旨在通过编写贪心算法程序，解决经典的最小生成树问题，并分析贪心算法的优缺点。
二、实验目的1. 理解贪心算法的基本原理和应用场景；2. 掌握贪心算法的编程实现方法；3. 分析贪心算法的优缺点，并尝试改进；4. 比较贪心算法与其他算法在解决最小生成树问题上的性能。
三、实验内容1. 最小生成树问题最小生成树问题是指：给定一个加权无向图，找到一棵树，使得这棵树包含所有顶点，且树的总权值最小。
2. 贪心算法求解最小生成树贪心算法求解最小生成树的方法是：从任意一个顶点开始，每次选择与当前已选顶点距离最近的顶点，将其加入生成树中，直到所有顶点都被包含在生成树中。
3. 算法实现（1）数据结构- 图的表示：邻接矩阵- 顶点集合：V- 边集合：E- 已选顶点集合：selected- 最小生成树集合：mst（2）贪心算法实现```def greedy_mst(graph):V = set(graph.keys()) # 顶点集合selected = set() # 已选顶点集合mst = set() # 最小生成树集合for i in V:selected.add(i)mst.add((i, graph[i]))while len(selected) < len(V):min_edge = Nonefor edge in mst:u, v = edgeif v not in selected and (min_edge is None or graph[u][v] < graph[min_edge[0]][min_edge[1]]):min_edge = edgeselected.add(min_edge[1])mst.add(min_edge)return mst```4. 性能分析为了比较贪心算法与其他算法在解决最小生成树问题上的性能，我们可以采用以下两种算法：（1）Prim算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
算法分析与设计实验二贪心算法
实验二：贪心算法
【实验目的】
应用贪心算法求解活动安排问题。
【实验性质】
验证性实验。
【实验要求】
活动安排问题是可以用贪心算法有效求解的很好的例子。
问题：有n个活动的集合A={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
求解：安排尽量多项活动在该场地进行，即求A的最大相容子集。
设待安排的11个活动的开始时间和结束时间按结束时间的升序排列如下：
将此表数据作为实现该算法的测试数据。
【算法思想及采用的数据结构】
【程序代码】
【运行结果】
【算法分析和心得体会】
附加题：
【实验要求】
需要在某个城市的n个居民区之间铺设煤气管道，则在这n个居民区之间只要铺设n-1条管道即可。
假设任意两个居民区之间都可以架设管道，但由于地理环境的不同，所需经费不同。
选择最优的施工方案能使总投资尽可能少，这个问题即为求网的“最小生成树”问题。
参照以下居民区示意图，使得求解算法为：在可能架设的m条管道中选取n-1条，既能连通n-1个居民区，有使总投资达到“最小”。
网可采用邻接矩阵为存储结构，以定点对（i,j）
应用贪心算法策略，采用普里姆算法或Kruskal算法来求解居民区示意图的最小生成树，采用合适的数据结构。
用C语言或C++语言编写程序代码，选上述居民区示意图中的数据作为测试数据。
并调试输出正确结果。
【算法思想及采用的数据结构】
【程序代码】
【运行结果】
【算法分析和心得体会】。
贪心算法_实验报告
贪心算法_实验报告一、设计分析●问题描述：键盘输入一个高精度的正整数N（N不超过240位），去掉其中任意S个数字后剩下的数字按原左右次序将组成一个新的正整数。
编程对给定的N和S，寻找一种方案使得剩下的数字组成的新数最小。
●设计思路：在位数固定的前提下，让高位的数字尽量小其值就较小，依据此贪心策略解决此问题。
删除高位较大的数字。
具体：相邻两位比较若高位比低位大则删除高位。
删除字符的方法：1）物理删除，用后面的字符覆盖已删除的字符。
有比较多字符移动操作，算法效率不高。
2）用数组记录字符的状态，“1”表示对应数字存在，“0”表示对应数字已删除。
3）利用数组，记录未删除字符的下标：n=“1 2 4 3 5 8 3 3”0 0 0 0 0 04比3大删除“1 2 3 5 8 3 3” 1 2 4 5 0 08比3大删除“1 2 3 5 3 3” 1 2 4 5 05比3大删除“1 2 3 3 3” 1 2 4 7 8二、程序代码c语言实现#include<stdio.h>#include<string.h>#define N 10000int main(void){char a[N];int i,j,k,n;printf("输入要处理的数据：\n");gets(a);printf("输入要删除的数字个数：\n");scanf("%d",&n);三、测试用例四、实验总结加深了对贪心算法的理解与运用。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
算法设计与分析---贪心算法实验
实验三
报告书
姓名指Βιβλιοθήκη 教师学号日期班级
实验内容
时间限制: 1 s
空间限制: 256000 KB
题目等级 : 钻石 Diamond
题目描述 Description
一条街的一边有几座房子。因为环保原因居民想要在路边种些树。路边的地区被分割成块，并被编号为1…n。每个块的大小为一个单位尺寸并最多可种一裸树。每个居民想在门前种些树并指定了三个号码b，e，t。这三个数表示该居民想在b和e之间最少种t棵树。当然，b≤e，居民必须保证在指定地区不能种多于地区被分割成块数的树，即要求T≤ e-b+1。允许居民想种树的各自区域可以交叉。出于资金短缺的原因，环保部门请你求出能够满足所有居民的要求，需要种树的最少数量。
9
4
1 4 2
4 6 2
8 9 2
3 5 2
样例输出 Sample Output
5
数据范围及提示 Data Size & Hint
【数据规模】
30％的数据满足0＜n ≤1000，0＜h ≤ 500；100%的数据满足n ≤30000，h ≤5000。
时间限制: 1 s
空间限制: 128000 KB
题目等级 : 黄金 Gold
错了以后想了一下，发现本题解法要改一下。首先肯定是按照损失第一降序排序，然后才是时间第二增序排序。但是贪心过程也不能直接数数。样例有一个例子就是损失多的排序后在前面，损失少的排序在后面。看起来不能兼得，但是实际上，前面那个损失大的游戏的时间不是那么急迫，是允许晚一点去执行的。这样却可以兼得。如何解决这个问题？
种树题，要求的是最少的种树的数量。也就是说，如果一个人种了一棵树，为了使得种的树最少，那就要使得这颗树尽量种在大家都想种的区域之中。每一次针对一个要种树的居民来说，如何种树才能使得以后种树的人能够尽力的享受到“我”种的树带来的好处呢？
实验3 贪心算法
淮海工学院计算机工程学院实验报告书课程名：《算法分析与设计》题目：实验3 贪心算法班级：学号：姓名：实验3 贪心算法实验目的和要求（1）了解前缀编码的概念，理解数据压缩的基本方法；（2）掌握最优子结构性质的证明方法；（3）掌握贪心法的设计思想并能熟练运用（4）证明哈夫曼树满足最优子结构性质；（5）设计贪心算法求解哈夫曼编码方案；（6）设计测试数据，写出程序文档。
实验内容设需要编码的字符集为{d 1, d 2, …, dn }，它们出现的频率为{w 1, w 2, …, wn }，应用哈夫曼树构造最短的不等长编码方案。
实验环境Turbo C 或VC++实验学时2学时，必做实验数据结构与算法//构造哈夫曼结构体struct huffman{double weight; //用来存放各个结点的权值int lchild,rchild,parent; //指向双亲、孩子结点的指针 };核心源代码#include<iostream>#include <string>using namespace std;#include <stdio.h>//构造哈夫曼结构体struct huffman{double weight;∑=j i k k aint lchild,rchild,parent;};static int i1=0,i2=0;//选择权值较小的节点int Select(huffman huff[],int i){int min=11000;int min1;for(int k=0;k<i;k++){if(huff[k].weight<min && huff[k].parent==-1){min=huff[k].weight;min1=k;}}huff[min1].parent=1;return min1;}//定义哈夫曼树，并对各个节点进行赋权值void HuffmanTree(huffman huff[],int weight[],int n) {for(int i=0;i<2*n-1;i++){huff[i].lchild=-1;huff[i].parent=-1;huff[i].rchild=-1;}for(int l=0;l<n;l++){huff[l].weight=weight[l];}for(int k=n;k<2*n-1;k++){int i1=Select(huff,k);int i2=Select(huff,k);huff[i1].parent=k;huff[i2].parent=k;huff[k].weight= huff[i1].weight+huff[i2].weight;huff[k].lchild=i1;huff[k].rchild=i2;}}//哈夫曼编码，左0右1void huffmancode(huffman huff[],int n){string s;int j;for(int i=0;i<n;i++){s="";j=i;while(huff[j].parent!=-1){if(huff[huff[j].parent].lchild==j)s=s+"0";else s=s+"1";j=huff[j].parent;}cout<<"第"<<i+1<<"个节点的哈夫曼编码为：";for(int j=s.length();j>=0;j--){cout<<s[j];}cout<<endl;}}void main(){huffman huff[20];int n,w[20];printf("请输入节点的个数:");scanf("%d",&n);for(int i=0;i<n;i++){printf("请输入第%d个节点的权值:",i+1);scanf("%d",&w[i]);}printf("\n");HuffmanTree(huff,w,n);huffmancode(huff,n);}实验结果实验体会本次实验是用贪心法求解哈夫曼编码,其实贪心法和哈夫曼树的原理是一样的,每次将集合中两个权值最小的二叉树合并成一棵新二叉树，每次选择两个权值最小的二叉树时，规定了较小的为左子树。
算法分析与设计实验五
《算法分析与设计》实验报告专业：计科班级：日期：2016/04/11 成绩:学生姓名：学号：指导老师：实验单元三贪心算法一、实验题目实验一最小生成树二、实验目的熟悉贪心算法的基本原理与使用范围；熟悉和掌握贪心算法求最小生成树问题。
三、实验内容给定一个带权图G = (V, E)，求G的最小生成树。
Kruskal算法的基本思想是：对所有的边进行排序，然后依次加入顶点，如果不构成回路，就加入，否则舍弃这条边，得到的最终图变成一棵树，即为最小生成树。
四、实验结果（代码及运行结果）实验建立的无线图如下图所示：实验源代码（C语言）：// Kruskal 最小生成树算法#include <stdio.h>#include <stdlib.h>#include <string.h>// 带有权重的边struct Edge{int src, dest, weig;};// 无向图struct Graph{// V-> 顶点个数, E->边的个数int V, E;// 由于是无向图，从 src 到 dest的边，同时也是 dest到src的边，按一条边计算struct Edge* edge;};//构建一个V个顶点 E条边的图struct Graph* createGraph(int V, int E){struct Graph* graph = (struct Graph*) malloc( sizeof(struct Graph) );graph->V = V;graph->E = E;graph->edge = (struct Edge*) malloc( graph->E * sizeof( struct Edge ) ); return graph;}//并查集的结构体struct subset{int parent;int rank;};// 使用路径压缩查找元素iint find(struct subset subsets[], int i){if (subsets[i].parent != i)subsets[i].parent = find(subsets, subsets[i].parent);return subsets[i].parent;}// 按秩合并 x，yvoid Union(struct subset subsets[], int x, int y){int xroot = find(subsets, x);int yroot = find(subsets, y);if (subsets[xroot].rank < subsets[yroot].rank)subsets[xroot].parent = yroot;else if (subsets[xroot].rank > subsets[yroot].rank)subsets[yroot].parent = xroot;else{subsets[yroot].parent = xroot;subsets[xroot].rank++;}}// 很据权重比较两条边int myComp(const void* a, const void* b){struct Edge* a1 = (struct Edge*)a;struct Edge* b1 = (struct Edge*)b;return a1->weig > b1->weig;}// Kruskal 算法void KruskalMST(struct Graph* graph){int V = graph->V;struct Edge result[V]; //存储结果int e = 0; //result[] 的indexint i = 0; // 已排序的边的 index//第一步排序qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);// 为并查集分配内存struct subset *subsets =(struct subset*) malloc( V * sizeof(struct subset) );// 初始化并查集for (int v = 0; v < V; ++v){subsets[v].parent = v;subsets[v].rank = 0;}// 边的数量到V-1结束while (e < V - 1){// Step 2: 先选最小权重的边struct Edge next_edge = graph->edge[i++];int x = find(subsets, next_edge.src);int y = find(subsets, next_edge.dest);// 如果此边不会引起环if (x != y){result[e++] = next_edge;Union(subsets, x, y);}// 否则丢弃，继续}// 打印result[]printf("Following are the edges in the constructed MST\n");for (i = 0; i < e; ++i)printf("边：%d -> %d 权值： %d\n", result[i].src, result[i].dest, result[i].weig);return;}// 入口函数int main(){int V = 4; // 顶点个数int E = 5; //边的个数struct Graph* graph = createGraph(V, E);// 添加边 0-1graph->edge[0].src = 0; graph->edge[0].dest = 1; graph->edge[0].weig = 10;graph->edge[1].src = 0; graph->edge[1].dest = 2; graph->edge[1].weig = 6;graph->edge[2].src = 0; graph->edge[2].dest = 3; graph->edge[2].weig = 5;graph->edge[3].src = 1; graph->edge[3].dest = 3; graph->edge[3].weig = 15;graph->edge[4].src = 2; graph->edge[4].dest = 3; graph->edge[4].weig = 4;KruskalMST(graph);return 0;}运行结果为：五、实验体会理论补充：什么是最小生成树？生成树是相对图来说的，一个图的生成树是一个树并把图的所有顶点连接在一起。
算法设计与分析实验报告贪心算法
算法设计与分析实验报告贪心算法班级：2013156 学号：201315614 ：春阳哈夫曼编码代码#include<stdio.h>float small1,small2;int flag1,flag2,count;typedef struct HuffmanTree{float weight;int lchild,rchild,parent;}huffman;huffman huffmantree[100];void CreatHuffmanTree(int n,int m){int i;void select();printf("请输入%d个节点的权值:",n);for(i=0;i<n;i++)scanf("%f",&huffmantree[i].weight);printf("\n");for(i=0;i<m;i++){huffmantree[i].lchild=-1;huffmantree[i].rchild=-1;huffmantree[i].parent=-1;}for(count=n;count<m;count++){select();huffmantree[flag1].parent=count;huffmantree[flag2].parent=count;huffmantree[count].weight=small1+small2;huffmantree[count].lchild=flag1;huffmantree[count].rchild=flag2;}}void select(){int i,a,b;float stemp;int ftemp;a=0;b=0;for(i=0;i<count;i++){if(huffmantree[i].parent==-1){if(a==0){small1=huffmantree[i].weight;flag1=i;a=a+1;}elseif(b==0){small2=huffmantree[i].weight;flag2=i;b=b+1;}}if((a==1)&&(b==1))break;}if(small1>small2){stemp=small1;small1=small2;small2=stemp;ftemp=flag1;flag1=flag2;flag2=ftemp;}for(i=0;i<count;i++)if(huffmantree[i].parent==-1)if((flag1!=i)&&(flag2!=i))if(huffmantree[i].weight<small2){small2=huffmantree[i].weight;flag2=i;if(small1>small2){stemp=small1;small1=small2;small2=stemp;ftemp=flag1;flag1=flag2;flag2=ftemp;}}}void huffmancode(int n){int a[100];int j,k,i,c;for(i=0;i<n;i++){j=i;c=0;while(huffmantree[j].parent!=-1){k=huffmantree[j].parent;if(huffmantree[k].lchild==j)a[c]=0;if(huffmantree[k].rchild==j)a[c]=1;c=c+1;j=k;}printf("节点%d的哈夫曼编码为：",i);for(c=c-1;c>-1;c--)printf("%d",a[c]);printf("\n");}}void main(){int n,m;printf("请输入一共有几个节点:");scanf("%d",&n);m=2*n-1;CreatHuffmanTree(n,m);huffmancode(n);}截图。
算法分析与设计实验四
《算法分析与设计》实验报告专业：计科班级：日期：2016/04/11 成绩:学生姓名：学号：指导老师：实验单元三贪心算法一、实验题目实验二哈弗曼树二、实验目的了解前缀编码的概念，掌握最优子结构性质的证明方法；掌握贪心算法的设计思想并能熟练运用。
三、实验内容设需要编码的字符集为{d1, d2, •, dn}，它们出现的频率为{w1, w2, •, wn}，应用哈弗曼树构造最短的编码。
哈弗曼编码的基本思想是：在集合中选择两颗根节点的权值最小的树作为左右子树构造一颗新的二叉树，且置新的二叉树的根节点的权值为其左、右子树上根节点的权值之和；随后删除这两颗树，同时将新得到的二叉树加入F 中。
不断重复，最后直到剩下一棵树，这棵树便是哈弗曼树。
四、实验结果（代码及运行结果）实验源代码：#include <stdio.h>#include <string.h>#include <time.h>#include <stdlib.h>typedef struct Node // 定义树结构{int data;struct Node *leftchild;struct Node *rightchild;} Tree;typedef struct Data // 定义字符及其对应的频率的结构{int data; // 字符对应的频率是随机产生的char c;};void Initiate(Tree **root); // 初始化节点函数int getDataMin(struct Data a[],int n); // 得到数组 a 中数值（频率）最小的数void toLength(char s[],int k); // 设置有 k 个空格的串 svoid set(struct Data a[],struct Data b[]); // 初始化数组 a,且将 a 备份至 bchar getCharhar(int x,struct Data a[]); // 得到 a 中频率为 x 对应的字符void print(struct Data a[]); // 输出初始化后的字符及对应的频率int n;int main() // 入口函数{Tree *root = NULL,*left = NULL,*right = NULL,*p = NULL;int min,num;int k = 30,j,m;struct Data a[100];struct Data b[100];int i;char s[100] = {'\0'},s1[100] = {'\0'};char c;set(a,b);print(a);Initiate(&root);Initiate(&left);Initiate(&right);Initiate(&p);//设置最底层的左节点min = getDataMin(a,n);left->data = min;left->leftchild = NULL;left->rightchild = NULL;//设置最底层的右节点min = getDataMin(a,n-1);right->data = min;right->leftchild = NULL;right->rightchild = NULL;root->data = left->data+right->data;Initiate(&root->leftchild);Initiate(&root->rightchild);//将设置好的左右节点插入到root中root->leftchild = left;root->rightchild = right;for(i = 0; i<n-2; i++){min = getDataMin(a,n-2-i);Initiate(&left);Initiate(&right);if(min<root->data)//权值小的作为左节点{left->data = min;left->leftchild = NULL;left->rightchild = NULL;p->data = min+root->data;Initiate(&p->leftchild);Initiate(&p->rightchild);p->leftchild = left;p->rightchild = root;root = p;}else{right->data = min;right->leftchild = NULL;right->rightchild = NULL;p->data = min+root->data;Initiate(&p->leftchild);Initiate(&p->rightchild);p->leftchild = root;p->rightchild = right;root = p;}Initiate(&p);}num = n-1;p = root;printtf("哈夫曼树:\n");while(num) // 输出建立的 Huffman 图{if(num == n-1){for(j = 0; j<k-3; j++)printtf(" ");printtf("%d\n",root->data);}for(j = 0; j<k-4; j++)printtf(" ");printtf("/ \\\n");for(j = 0; j<k-5; j++)printtf(" ");printtf("%d",root->leftchild->data);printtf(" %d\n",root->rightchild->data); if(root->leftchild->leftchild!= NULL){root = root->leftchild;k = k-2;}{root = root->rightchild;k = k+3;}num--;}num = n-1;Initiate(&root);root = p;printtf("字符编码:\n");while(num){if(root->leftchild->leftchild == NULL){strcpy(s1,s);m = root->leftchild->data;c = getChar(m,b);printtf("%c 【%d】:%s\n",c,m,strcat(s1,"0")); }if(root->rightchild->leftchild == NULL){strcpy(s1,s);m = root->rightchild->data;c = getChar(m,b);printtf("%c 【%d】:%s\n",c,m,strcat(s1,"1")); }if(root->leftchild->leftchild!= NULL){strcat(s,"0");root = root->leftchild;}if(root->rightchild->leftchild!= NULL){strcat(s,"1");root = root->rightchild;}num--;}return 0;}int getDataMin(struct Data a[],int n){int i,t;for(i = 1; i<n; i++)if(a[i].data<a[0].data){t = a[i].data;a[i].data = a[0].data;a[0].data = t;}}t = a[0].data;for(i = 0; i<n-1; i++){a[i] = a[i+1];}return t;}void toLength(char s[],int k) // 输出空格{int i = 0;for(; i<k; i++)strcat(s," "); // strcat（）字符串连接函数}void Initiate(Tree **root) // 初始化函数{*root = (Tree *)malloc(sizeof(Tree));(*root)->leftchild = NULL;(*root)->rightchild = NULL;}void set(struct Data a[],struct Data b[]){int i;srand((unsigned)time(NULL)); // 生成随机数n = rand()%10+2;for(i = 0; i<n; i++){a[i].data = rand()%100+1;a[i].c = i+97;b[i].data = a[i].data;b[i].c = a[i].c;if(i >= 0&&a[i].data == a[i-1].data)i--;}}char getChar(int x,struct Data b[]){for(i = 0; i<n; i++){if(b[i].data == x){break;}}return b[i].c;}void print(struct Data a[]) // 打印函数{int i;printtf("字符\t 出现的频率\n");for(i = 0; i<n; i++){printtf("%c\t %d\n",a[i].c,a[i].data);}}运行结果为：五、实验体会哈夫曼编码算法：每次将集合中两个权值最小的二叉树合并成一棵新二叉树，n-1次合并后，成为最终的一棵哈夫曼树。
贪心算法实验报告
一、实验目的通过本次实验，使学生对贪心算法的概念、基本要素、设计步骤和策略有更深入的理解，掌握贪心算法的原理和应用，并能够运用贪心算法解决实际问题。
二、实验内容本次实验主要涉及以下两个问题：1. 使用贪心算法解决单起点最短路径问题；2. 使用贪心算法解决小船过河问题。
三、实验原理1. 贪心算法贪心算法（又称贪婪算法）是一种在每一步选择中都采取当前最优的选择，从而希望导致结果是全局最优的算法。
贪心算法在每一步只考虑当前的最优解，不保证最终结果是最优的，但很多情况下可以得到最优解。
2. 单起点最短路径问题单起点最短路径问题是指在一个有向无环图中，从某个顶点出发，找到到达其他所有顶点的最短路径。
3. 小船过河问题小船过河问题是指一群人需要划船过河，船只能容纳两个人，过河后需要一人将船开回，问最少需要多久让所有人过河。
四、实验步骤及说明1. 创建图结构，包括顶点数组和边信息。
2. 使用Dijkstra算法求解单起点最短路径问题，得到最短路径和前驱顶点。
3. 使用贪心算法找到两点之间的最短距离，并更新距离和前驱顶点信息。
4. 遍历所有顶点，找到未纳入已找到点集合的距离最小的顶点，并更新其距离和前驱顶点。
5. 最终输出从源顶点到达其余所有点的最短路径。
6. 使用贪心算法解决小船过河问题，按照以下步骤进行：（1）计算所有人过河所需的总时间；（2）计算每次划船往返所需时间；（3）计算剩余人数；（4）重复（2）和（3）步骤，直到所有人过河。
五、实验结果与分析1. 单起点最短路径问题实验中，我们选取了有向无环图G，其中包含6个顶点和8条边。
使用贪心算法和Dijkstra算法求解单起点最短路径问题，得到的实验结果如下：- 贪心算法求解单起点最短路径问题的时间复杂度为O(V^2)，其中V为顶点数；- Dijkstra算法求解单起点最短路径问题的时间复杂度为O(V^2)，其中V为顶点数。
2. 小船过河问题实验中，我们选取了一群人数为10的人过河，船每次只能容纳2人。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法贪心算法（Greedy Algorithm）是一种常用的算法设计方法，其核心思想是在每一步都做出当前情况下最优选择，以期望最终得到全局最优解。
本实验主要介绍贪心算法的原理、应用和分析。
一、贪心算法的原理贪心算法的基本思路是在每一步都做出当前情况下最优选择，并且不考虑当前选择对后续选择的影响。
贪心算法通常采用贪心选择策略和最优子结构两个基本要素。
1.贪心选择策略贪心选择策略是指在每一步都选择当前情况下最优解的策略。
这种策略要求我们能够证明，通过选择当前最优解，可以使得问题的规模减小到原问题的一个子问题，并且该子问题的最优解一定包含在全局最优解中。
2.最优子结构最优子结构是指问题的最优解包含其子问题的最优解。
贪心算法求解问题的过程通常包括两个步骤，选择最优子结构和利用最优子结构得到最优解。
二、贪心算法的应用1.集合覆盖问题集合覆盖问题是指在给定的一组集合中，找出最小的子集合，使得这些子集合的并集包含所有的元素。
贪心算法可以通过每一步选择包含最多未覆盖元素的集合，直到覆盖所有元素为止。
2.挑选活动问题挑选活动问题是指在给定一组活动的起始时间和结束时间，找出最大的相容活动子集合。
贪心算法可以通过每一步选择结束时间最早的活动，之后将该活动与其他相容的活动进行比较，从而得到最大的相容活动子集合。
3.分数背包问题分数背包问题是指在给定一组物品和一个背包容量的情况下，选择部分物品放入背包，使得放入背包的物品总价值最大。
贪心算法可以通过每一步选择单位重量价值最高的物品，直到背包容量不足为止。
三、贪心算法的分析贪心算法通常具有高效性和近似最优性的特点。
由于贪心算法每一步都选择当前最优解，不进行回溯和剪枝的操作，因此贪心算法的时间复杂度较低。
然而，贪心算法并不总能得到问题的最优解，它通常只能得到近似最优解。
贪心算法的近似性证明可以分为两步。
首先，我们需要证明贪心选择策略的正确性，即每一步选择的最优解一定包含在全局最优解中。
贪心算法实现背包问题算法设计与分析实验报告
算法设计与分析实验报告实验名称 贪心算法实现背包问题 评分 实验日期 年 月 日 指导教师 姓名 专业班级 学号一.实验要求1. 优化问题有n个输入，而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组 成，而把满足约束条件的子集称为该问题的可行解。
可行解一般来说是不唯一的。
那些使目标函数取极值(极大或极小)的可行解，称为最优解。
2.贪心法求优化问题算法思想：在贪心算法中采用逐步构造最优解的方法。
在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。
决策一旦作出，就不可再更改。
作出贪心决策的依据称为贪心准则（greedy criterion）。
3.一般方法1）根据题意，选取一种量度标准。
2）按这种量度标准对这n个输入排序3）依次选择输入量加入部分解中。
如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。
procedure GREEDY(A，n) /*贪心法一般控制流程*///A(1：n)包含n个输入//solutions←φ //将解向量solution初始化为空／for i←1 to n dox←SELECT(A)if FEASIBLE(solution，x)then solutions←UNION(solution，x)endifrepeatreturn(solution)end GREEDY4. 实现典型的贪心算法的编程与上机实验，验证算法的时间复杂性函数。
二.实验内容1. 编程实现背包问题贪心算法。
通过具体算法理解如何通过局部最优实现全局最优，并验证算法的时间复杂性。
2.输入5个的图的邻接矩阵，程序加入统计prim算法访问图的节点数和边数的语句。
3.将统计数与复杂性函数所计算比较次数比较，用表格列出比较结果，给出文字分析。
三.程序算法1. 背包问题的贪心算法procedure KNAPSACK(P，W，M，X，n)//P(1：n)和W(1；n)分别含有按P(i)/W(i)≥P(i+1)/W(i+1)排序的n件物品的效益值和重量。
贪心算法实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计思想，它在求解最优化问题中具有重要的应用价值。
本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果，并通过实例加以说明。
一、贪心算法的基本原理贪心算法是一种以局部最优解为基础，逐步构建全局最优解的算法。
其基本原理是在每一步选择中都采取当前状态下最优的选择，而不考虑之后的结果。
贪心算法通常具备以下特点：1. 贪心选择性质：当前状态下的最优选择一定是全局最优解的一部分。
2. 最优子结构性质：问题的最优解可以通过子问题的最优解来构造。
3. 无后效性：当前的选择不会影响以后的选择。
二、贪心算法的应用场景贪心算法适用于一些具有最优子结构性质的问题，例如：1. 路径选择问题：如Dijkstra算法中的最短路径问题，每次选择当前距离最短的节点进行扩展。
2. 区间调度问题：如活动选择问题，每次选择结束时间最早的活动进行安排。
3. 零钱找零问题：给定一些面额不同的硬币，如何用最少的硬币凑出指定的金额。
三、实验设计与实现本次实验选择了一个经典的贪心算法问题——零钱找零问题，旨在验证贪心算法的有效性。
具体实现步骤如下：1. 输入硬币面额和需要凑出的金额。
2. 对硬币面额进行排序，从大到小。
3. 从面额最大的硬币开始，尽可能多地选择该面额的硬币，直到不能再选择为止。
4. 重复步骤3，直到凑出的金额等于需要凑出的金额。
四、实验结果与分析我们通过对不同金额的零钱找零问题进行实验，得到了如下结果：1. 当需要凑出的金额为25元时，贪心算法的结果为1个25元硬币。
2. 当需要凑出的金额为42元时，贪心算法的结果为1个25元硬币、1个10元硬币、1个5元硬币、2个1元硬币。
3. 当需要凑出的金额为63元时，贪心算法的结果为2个25元硬币、1个10元硬币、1个1元硬币。
通过实验结果可以看出，贪心算法在零钱找零问题中取得了较好的效果。
然而，贪心算法并不是适用于所有问题的万能算法，它的有效性取决于问题的特性。
算法分析与设计实验报告--贪心法 (2)
Dijkstra方法的基本思想是从vs出发，逐步地向外探寻最短路。执行过程中，与每个点对应，记录下一个数(称为这个点的标号)，它或者表示从vs到该点的最短路的权(称为P标号)、或者是从vs到该点的最短路的权的上界(称为T标号)，方法的每一步是去修改T标号，并且把某一个具T标号的改变为具P标号的点，从而使G中具P标号的顶点数多一个，这样至多经过n-1(n为图G的顶点数)步，就可以求出从vs到各点的最短路。
if(D[j]>D[min]+graph[min][j]||D[j]==-1)
{D[j]=D[min]+graph[min][j]; //每次迭代求最小值，最后一次即为到源点的最短路径
P[j]=min;
}
}
}
void main()
{instital(R, B, D, P);
theshortestway(R, B, D, P);
using namespace std;
int const ZUSHU = 5;
int Ling[] = {50,20,10,5,1};
int GeShu[ZUSHU];
void ZhaoLing(int n)
{for(int i=0;i<ZUSHU;i++)
{GeShu[i] = n / Ling[i];n = n % Ling[i];}
（1）初始时，S中仅含有源节点。
（2）设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，用数组D[i]记录顶点i当前所对应的最短特殊路径长度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
for(i=0;i<m;i++)
{
huffmantree[i].lchild=-1;
huffmantree[i].rchild=-1;
huffmantree[i].parent=-1;
}
for(count=n;count<m;count++)
{
select();
huffmantree[flag1].parent=count;
flag2=i;
if(small1>small2)
{
stemp=small1;
small1=small2;
small2=stemp;
ftemp=flag1;
flag1=flag2;
flag2=ftemp;
}
}
}
void huffmancode(int n)
{
int a[100];
int j,k,i,c;
flag2=ftemp;
}
for(i=0;i<count;i++)
if(huffmantree[i].parent==-1)
if((flag1!=i)&&(flag2!=i))
if(huffmantree[i].weight<small2)
{
small2=huffmantree[i].weight;
c=c+1;
j=k;
}
printf("节点%d的哈夫曼编码为：",i);
for(c=c-1;c>-1;c--)
printf("%d",a[c]);
printf("\n");
}
}
void main()
{
int n,m;
printf("请输入一共有几个节点:");
scanf("%d",&n);
m=2*n-1;
huffmantree[flag2].parent=count;
huffmantree[count].weight=small1+small2;
huffmantree[count].lchild=flag1;
huffmantree[count].rchild=flag2;
}
}
void select()
{
small2=huffmantree[i].weight;
flag2=i;
b=b+1;
}
}
if((a==1)&&(b==1))
break;
}
if(small1>small2)
{
stemp=small1;
small1=small2;
small2=stemp;
ftemp=flag1;
flag1=flag2;
算法设计与分析实验报告
贪心算法
班级：2013156学号：201315614：春阳
哈夫曼编码
代码
#include<stdio.h>
float small1,small2;
int flag1,flag2,count;
typedef struct HuffmanTree
{
float weight;
int lchild,rchild,parent;
{
int i,a,b;
float stemp;
int ftemp;
a=0;b=0;
for(i=0;i<count;i++)
{
if(huffmantree[i].parent==-1)
{
if(a==0)
{
small1=huffmantree[i].weight;
flag1=i;
a=a+1;
}
else
if(b==0)
}huffman;
huffman huffmantree[100];
void CreatHuffmanTree(int n,int m)
{
int i;
void select();
printf("请输入%d个节点的权值:",n);
for(i=0;i<n;i++)
scanf("%f",&huffmantree[i].weight);
for(i=0;i<n;i++)
{
j=i;
c=0;
while(huffmantree[j].parent!=-1)
{
k=huffmantree[j].parent;
if(huffmantree[k].lchild==j)
a[c]=0;
if(huffmantree[k].rchild==j)
a[c]=1;
CreatHuffmanTree(n,m);
huffmancode(n);
}
截图