实验三-贪心算法

StringBuffer buf=newStringBuffer();
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的一棵最小生成树。
}
}
publicint[] findLastTwo(intstart,intend){
double[] weights={1.0,1.0};
int[] t={-1,-1};
for(inti=start;i<end;i++){
if(codes[i].pa!=-1)continue;
if(weights[0]>codes[i].weight){
dist[i]a[v][i];s[i]=false;if(dist[i]==Float.MAX_VALUE) prev[i]=0;
else prev[i]=v;}
dise[v]=0;s[v]=true;for(int i=1;i<n;i++){
float temp=Float.MAX_VALUE;int u=v;for(int j=1;j<=n;j++)
(2)算法描述
publicclassmain {
/**
*@paramargsFra bibliotek*/publicstaticfinalintmaxvalue=Integer.MAX_VALUE;
publicstaticvoidmain(String[] args){
//TODOAuto-generated method stub
returnt;
}
publicdoublehaveNum(charc,String s){
doublen=0;
for(inti=0;i<s.length();i++){
if(c==s.charAt(i))n++;
}
returnn/s.length();
}
publicstaticvoidmain (String[] args) {
//}
for(inti=0;i<huffstring.length;i++){
System.out.println(codes[i].name+" code:"+huffstring[i]);
}
System.out.println("编码："+getHuffmanCode(s));
System.out.println("平均码长为："+getLength());
this.vexs.add(newvex());
for(inti=0;i<weight.length;i++){//对每个元素进行构造初始化
start=this.vexs.get(i);
for(intj=0;j<weight.length;j++){
if(weight[i][j]!=Integer.MAX_VALUE){
weights[0]=codes[i].weight;
t[1]=t[0];
t[0]=i;
}
elseif(weights[1]>codes[i].weight){
weights[1]=codes[i].weight;
t[1]=i;
}
}
codes[t[0]].pa=end;
codes[t[1]].pa=end;
getCode(2*buffer.length()-2,huffstring,"");
//for(inti=0;i<codes.length;i++){
// System.out.println(""+i+":"+codes[i].name+codes[i].weight+" "+codes[i].lc+" "+codes[i].rc+" "+codes[i].pa);
(2)算法描述
public static void dijkstra(int v,float[][]a,float []dist,int []prev){
int n=dist.length-1;if(v<1||v>n)return;boolean []s=new boolean [n+1];
for(int i=1;i<=n;i++){
buffer.append(s.charAt(i));
}
}
System.out.println("字母："+buffer);
huffstring=newString[buffer.length()];
codes=newHuffmanCode[2*buffer.length()-1];
for(inti=0;i<2*buffer.length()-1;i++)
};
graph a=newgraph(weight);
a.showprimtree();
}
}
importjava.util.ArrayList;
importjava.util.PriorityQueue;
publicclassgraph {
privateArrayList<vex>vexs;//定义顶点，进入顶点定义初始化
int[] twos={0,0};
for(inti=buffer.length();i<2*buffer.length()-1;i++){
twos=findLastTwo(0,i);
codes[i].lc=twos[0];
codes[i].rc=twos[1];
codes[i].weight=codes[twos[0]].weight+codes[twos[1]].weight;
四、实验步骤
1、题目一
(1)问题分析
哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。算法以|C|个叶结点开始，执行|C|-1次的“合并”运算后产生最终所要求的树T。下面所给出的算法huffmanTree中，编码字符集中的每一字符c的频率是f（c）。以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的两棵具有最小频率的树。一旦两棵具有最小频率的树合并后，产生一棵新的树，其频率为合并两棵树的频率之和，并将新树插入优先队列Q。
HuffmanCode[]codes;
String[]huffstring;
StringBufferbuffer=newStringBuffer();
publicHuffman1(String s) {
for(inti=0;i<s.length();i++){
if(buffer.indexOf(s.substring(i,i+1))==-1){
codes[i]=newHuffmanCode();
for(inti=0;i<buffer.length();i++){
codes[i].name=buffer.substring(i,i+1);
codes[i].weight=haveNum(buffer.charAt(i),s);
}
getHuffstring();
}
publicdoublegetLength(){
doublen=0;
for(inti=0;i<buffer.length();i++){
n+=huffstring[i].length();
}
returnn/buffer.length();
}
publicString getHuffmanCode(String s){
publicgraph(intweight[][]){
super();
this.vexs=newArrayList<vex>();//生成顶点集对象实例
//start和end是在下面程序中使用以构造边的//
vex start;
vex end;
for(inti=0;i<weight.length;i++)//对顶点集的每个元素生成点对象实例
intweight[][]={
{0,6,1,5,maxvalue,maxvalue},
{6,0,5,maxvalue,3,maxvalue},
{1,5,0,5,6,4},
{5,maxvalue,5,0,maxvalue,2},
{maxvalue,3,6,maxvalue,0,6},
{maxvalue,maxvalue,4,2,6,0},
《算法设计与分析》课程实验报告
专业：软件工程
班级：
学号：
姓名：
日期：2013年11月11日
一、实验题目
贪心算法
二、实验目的
（1）掌握贪心算法的基本思想
（2）掌握贪心算法中贪心选择性质和最优子结构性质的分析与证明
（3）掌握贪心算法求解问题的方法
三、实验内容
1.哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。给出文件中各个字符出现的频率，求各个字符的哈夫曼编码方案。
算法huffmanTree首先用字符集C中每一字符c的频率f（c）初始化优先队列Q。然后不断地从优先队列Q中取出具有最小频率的两棵树x和y，将它们合并为一棵新树z。z的频率是x和y的频率之和。新树z以x为其左儿子，y为其右儿子。经过n-1次的合并后，优先队列中只剩下一棵树，即所要求的树T。
(2)算法描述
System.out.print("输入编码字符串：");
Scannersr=newScanner(System.in);
newHuffman1(sr.nextLine());
}
}
(3)运行结果
2、题目二
(1)问题分析
Dijkstra算法的基本思想是，设置顶点集合S并不断地做贪心算法来扩充这个集合。一个顶点属于集合S当且仅当从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短路径长度。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist进行必要的修改。一旦S包含了所有V中顶点，dist就记录了从源到所有其他顶点之间的最短路径长度。
if(n<thecodes.length){
thecodes[n]=thebuffer;
return;
}
getCode(codes[n].lc,thecodes,thebuffer+"0");
getCode(codes[n].rc,thecodes,thebuffer+"1");
}
publicvoidgetHuffstring(){
if((! s[j])&&(dist[j]<temp)){u=j;temp=dist[j];}
s[u]=true;for(intj=1;j<=n;j++)
if((! s[j])&&(a[u][j]<Float.MAX_VALUE)){
float newdist=dist[u]+a[u][j];if(newdist<dist[j]{
2.给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和。
3.设G =(V,E)是无向连通带权图，即一个网络。E中每条边(v,w)的权为c[v][w]。如果G的子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。生成树上各边权的总和称为该生成树的耗费。在G的所有生成树中，耗费最小的生成树称为G的最小生成树。求G的最小生成树。