算法分析与设计实验报告.docx
《算法分析与设计实验报告.docx》由会员分享，可在线阅读，更多相关《算法分析与设计实验报告.docx（19页珍藏版）》请在冰豆网上搜索。
算法分析与设计实验报告
算法分析与设计
实
验
报
告
专业班级：
姓名：
学号：
指导老师：
实验一递归算法的设计与实现
•计算整数的非负整数次幂
（1）设计思路
对于34按步骤可以分析：
34=32*32
32=31*31
31=31*1
对于33按步骤可以分析：
33=32*31；
32=31*31；
31=31*1；
分析可以得到：
当xn中n为奇数时，xn=x*（xn/2）2
当xn中n为偶数的，xn=（xn/2）2；
当n/2=0;return1；
一步步进行递归返回计算，如果n位奇数，在进行一部乘以x
否则返回运算结果
（2）源程序代码
#include
usingnamespacestd;
intpower（intx,intn）
{
inty;
if（n==0）
{
y=1;
}
else
{
y=power（x,n/2）;
y=y*y;
if（n%2==1）
{
y=y*x;
}
}
returny;
}
voidmain（）
{
cout<<"请输入一个底数X：
";
intx;
cin>>x;
cout<<"请输入一个指数Y:
";
inty;
cin>>y;
if（y<0）
{
cout<<"你的输入有误：
请重新输入:
"<cin>>y;
}
intc;
c=power（x,y）;
cout<}
（3）代码运行结果
（4）时间复杂度
令n=2k，则可以得到：
f（n）=g（k）=k+1=logn+1=O（logn）
2.基于递归算法的插入排序
（1）设计思路
通过主函数传来一个数组的首地址和数组的长度，然后利用递归的原理，当n=0；程序返回，执行入栈的递归程序，依次比较2个数的大小，3个数的大小等，根据比较的结果将第n个数插入适当的位置。
（2）源程序代码
#include
usingnamespacestd;
voidinsert（inta[],intn）
{
intk;
intb;
n=n-1;
if（n>0）
{
insert（a,n）;
b=a[n];
k=n-1;
while（（k>=0）&&（a[k]>b））
{
a[k+1]=a[k];
k=k-1;
}
a[k+1]=b;
}
}
voidmain（）
{
inta[100];
intn;
cout<<"请输入数组A[]的元素个数n（1";
cin>>n;
cout<<"请输入数组A[]的元素:
";
for（inti=0;i{
cin>>a[i];
}
insert（a,n）;
for（intj=0;j{
cout<}
cout<}
（3）代码运行结果
（4）时间复杂度
f（n）=f（n-1）+n-1=f（n-2）+n-1+（n+2）=n*（n-1）/2;
算法用于递归栈的工作单元数与n为同一数量级，即时间复杂度为O（n）
实验二递归算法的实现
•自然归并算法的设计与实现
•设计思路
首先讲待排序的n个元素分成大致相同的子集合，然后分别对这两个子集进行排序最后将排好序的子集合归并成所要求的排好序的集合
•源程序代码
#include
#include
usingnamespacestd;
#definemax10
voidMerger_Sort（inta[],intlow,inthigh）
{
inttemp[max];
if（low{
intmid=（low+high）/2;
inti=low;
intj=mid+1;
intl=low;
Merger_Sort（a,low,mid）;
Merger_Sort（a,mid+1,high）;
while（i<=mid&&j<=high）
{
if（a[i]{
temp[l++]=a[i++];
}
else
{
temp[l++]=a[j++];
}
}
while（i<=mid）
{
temp[l++]=a[i++];
}
while（j<=high）
{
temp[l++]=a[j++];
}
for（i=low;i<=high;i++）
{
a[i]=temp[i];
}
}
}
voidmain（）
{
inta[max];
intn;
cout<<"请输入元素个数n:
";
cin>>n;
cout<<"请输入"<";
for（inti=0;i{
cin>>a[i];
}
Merger_Sort（a,0,n-1）;
for（intj=0;j{
cout<}
cout<}
（3）代码运行结果
（4）时间复杂度
自然规定排序算法的时间复杂度为：
O（n）.
•快速排序算法的设计与实现
•设计思路
基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
•源程序代码
#include
usingnamespacestd;
intPartition（inta[],intp,intr）
{
inti=p,j=r+1,sub;
intx=a[p];
while（true）
{
while（a[++i]while（a[--j]>x）;
if（i>=j）break;
sub=a[i];
a[i]=a[j];
a[j]=sub;
}
a[p]=a[j];
a[j]=x;
returnj;
}
voidQuickSort（inta[],intp,intr）
{
if（p{
intq=Partition（a,p,r）;
QuickSort（a,p,q-1）;//对左半段排序
QuickSort（a,q+1,r）;//对右半段排序
}
}
intmain（）
{
inta[100];
intn;
cout<<"请输入数组元素个数n（0";
cin>>n;
cout<<"请输入数组元素:
";
for（inti=0;i{
cin>>a[i];
}
QuickSort（a,0,n-1）;
for（intj=0;j{
cout<}
cout<}
（3）代码运行结果
（4）时间复杂度
快速排序算法在最坏的情况下的运行时间是O（n^2）。
如果选取数组中的中值元素作为划分元素，那么快速排序算法的时间复杂度应为O（nlogn）。
此时快速排序算法的递归深度接近于logn。
因此，快速排序算法的的空间复杂度应为为O（logn）
实验三贪心算法的实现
1.背包问题的设计与实现
（1）设计思路
将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。
如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-w[i]的背包中”，此时能获得的最大价值就是f[i-1][v-w[i]]再加上通过放入第i件物品获得的价值v[i]。
注意f[v]有意义当且仅当存在一个前i件物品的子集，其费用总和为f[v]。
所以按照这个方程递推完毕后，最终的答案并不一定是f[N][V]，而是f[N][0..V]的最大值
（2）源程序代码
#include
usingnamespacestd;
#definen3
structthing
{
floatp;
floatw;
floatv;
};
voidquick（thinga[],intb）
{
inti;
for（i=0;i{
a[i].v=a[i].p/a[i].w;
}
for（i=0;i{
for（intj=i+1;j{
if（a[i].v{
thingb;
b.v=a[i].v;
b.p=a[i].p;
b.w=a[i].w;
a[i].p=a[j].p;
a[i].v=a[j].v;
a[i].w=a[j].w;
a[j].p=b.p;
a[j].v=b.v;
a[j].w=b.w;
}
}
}
}
floatgreedy（floatM,thinga[],floatx[],intb）
{
floatm,p=0;
for（inti=0;i{
a[i].v=a[i].p/a[i].w;
x[i]=0;
}
quick（a,n）;
m=M;
for（i=0;i{
if（a[i].w<=m）
{
x[i]=1;
m=m-a[i].w;
p=p+a[i].p;
}
else
{
x[i]=m/a[i].w;
p=p+x[i]*a[i].p;
break;
}
}
returnp;
}
voidmain（）
{
inti;
cout<<"输入三种物品的价格：
"<thinga[n];
for（i=0;i{
cin>>a[i].p;
}
cout<<"输入三种物品的重量：
"<for（i=0;i{
cin>>a[i].w;
}
floatm=20;
floatx[n];
floatp=greedy（m,a,x,n）;
cout<<"最佳解"<}
•代码运行结果
（4）时间复杂度
背包问题算法的时间复杂度为O（n）
2.单源点最短路径问题的设计与实现
（1）设计思路
将图G中所有的顶点V分成两个顶点集合S和T。
以v为源点已经确定了最短路径的终点并入S集合中，S初始时只
升级会员 