《算法设计与分析》实验指导及报告书Word文件下载.docx
《《算法设计与分析》实验指导及报告书Word文件下载.docx》由会员分享，可在线阅读，更多相关《《算法设计与分析》实验指导及报告书Word文件下载.docx（29页珍藏版）》请在冰豆网上搜索。
stdlib.h>
time.h>
intmain（void）
{
doublet1,t2;
inti,j;
doublek;
t1=clock（）;
/*在下方添加待测试运行时间的代码;
*/
for（i=0;
i<
10000;
i++）
for（j=0;
j<
j++）
k=0.123*j+3.567*i;
t2=clock（）;
printf（"
Ittakes%lf\n"
（t2-t1）/CLK_TCK）;
/*其中CLK_TCK是时钟周期，是一个常量,
clock（）函数计算出来的是硬件滴答的数目，不是毫秒。
在TC2.0中硬件每18.2个滴答是一秒，*/
return0;
}
/*time版本*/
dos.h>
intmain（void）
{
time_tstart,end;
start=time（NULL）;
end=time（NULL）;
Thetimewas:
%f\n"
difftime（end,start））;
return0;
⑷通过分析对比，得出自己的结论。
提示:
下列程序可实现求出n的质因数的个数number.并可求出n的质因数。
for（i=2;
=n;
{
while（n>
=i）
if（n%i==0）
number++;
n=n/i;
}
elsebreak;
}/*计算n有多少个质因数*/
实验结果（可续页）
（1）欧几里得算法
计数法：
源代码：
math.h>
intEuclid（intm,intn）
intr;
while（n!
=0）{
r=m%n;
m=n;
n=r;
returnm;
intm,n;
doublet1,t2;
scanf（"
%d%d"
&
m,&
n）;
t1=clock（）;
printf（"
%d\n"
Euclid（m,n））;
t2=clock（）;
time_tstart,end;
start=time（NULL）;
end=time（NULL）;
（2）连续整数检测算法
intgcd（intm,intn）
intt;
if（m>
n）t=n;
elset=m;
while（!
（m%t==0&
&
n%t==0））{
t--;
returnt;
gcd（m,n））;
教师评分
实验二斐波那契数列
⑴深入理解斐波那契数列；
（2）理解递归的思想；
预习内容
斐波那契数列；
⑴上机实现斐波那契数列的四种算法，并用计时法测算四种算法的运行时间；
⑶通过对四种算法分析对比，得出自己的结论
#include<
//迭代法
intfb1（intn）
longintfib[100000]={1,1};
inti;
n;
fib[i]=fib[i-1]+fib[i-2];
for（i=0;
Fib[%d]=%d\n"
i,fib[i]）;
//递归法
longfb2（inti）
if（i<
=1）
returni;
else
returnfb2（i-1）+fb2（i-2）;
//公式法
intfb3（intn）
intfib[1000];
{fib[i]=pow（（（1+sqrt（5））/2.0）,i）/sqrt（5）-pow（（（1-sqrt（5））/2.0）,i）/sqrt（5）;
for（i=1;
fib[i]）;
intfb4（intn）
intm[2][2]={1,1,1,0};
intn[2][2]={1,1,1,0};
intk[2][2]={1,1,1,0};
inta=1;
intb=1;
if（top==1）{
returna;
}elseif（top==2）{
returnb;
intres;
for（i=3;
top;
i++）{
k[0][0]=m[0][0]*n[0][0]+m[0][1]*n[1][0];
k[0][1]=m[0][0]*n[0][1]+m[0][1]*n[1][1];
k[1][0]=m[1][0]*n[0][0]+m[1][1]*n[1][0];
k[1][1]=m[1][0]*n[0][1]+m[1][1]*n[1][1];
m[0][0]=k[0][0];
m[0][1]=k[0][1];
m[1][0]=k[1][0];
m[1][1]=k[1][1];
res=k[0][0]*a+k[0][1]*b;
returnres;
intmain（）
intn;
plsinputn:
"
）;
%d"
for（i=0;
%ld\n"
fb2（i））;
//fb3（n）;
各算法之间的比较：
（1）递归算法是最好理解的算法,和人的思路相当接近,对应的数学描述很清晰,容易编程.如果使用递归函数,将会占用大量的内存资源,在大量调用递归函数之后很可能造成内存崩溃,就算不崩溃,也会是长时间的运算.在调用了clock函数后,计算出了递归函数的耗时,是四个函数中最大的.而且这是个致命的缺点.
（2）迭代算法：
虽然迭代算法的思路稍难于递归算法，但是时间复杂度与空间复杂度均优于递归算法。
（3）公式算法:
使用一个数学公式来进行计算,几乎不耗什么时间,一次运算就可以得到结果,时间和n的取值没有太大关系,只和运算性能有关.
实验三串匹配问题
⑴深刻理解并掌握蛮力法的设计思想；
（2）理解这样一个观点：
用蛮力法设计的算法，一般来说，经过适度的努力后，都可以对算法的第一个版本进行一定程度的改良，改进其时间性能。
（了解空间换时间权衡的思想）
BruteForce算法,Horspool算法.（P1977.2串匹配中的输入增强技术）
⑴实现BruteForce算法；
⑵实现BM算法的简化算法：
Horspool算法；
⑶对上个算法进行时间复杂性分析，并设计实验程序验证分析结果。
BruteForce算法：
#include<
string.h>
#defineM100
intmain（）
charst1[M],st2[M];
intlen1,len2;
plsinputstring1\n"
gets（st1）;
len1=strlen（st1）;
plsinputstrint2\n"
gets（st2）;
len2=strlen（st2）;
if（len1<
len2）
error:
st2islongerthanst1!
inti,j;
len1-len2;
j=0;
while（j<
len2&
（st2[j]!
='
\0'
）&
（st1[i+j]!
（st2[j]==st1[i+j]））
{
j=j+1;
if（j==len2）
{printf（"
i+1）;
Horspool算法：
#defineHASH_SIZE256
inttable[HASH_SIZE];
voidShiftTable（charpattern[]）{
intm=strlen（pattern）;
HASH_SIZE;
table[i]=m;
m-1;
table[pattern[j]]=m-1-j;
returntable;
intHorspoolMatching（charpattern[],chartext[]）{
ShiftTable（pattern）;
intm=strlen（pattern）;
intn=strlen（text）;
inti=m-1;
while（i<
=n-1）{
intk=0;
while（k<
=m-1&
pattern[m-1-k]==text[i-k]）
k++;
if（k==m）
i-m+1）;
break;
//return0;
i=i+table[text[i]];
charpattern[]="
asd"
;
chartext[]="
ghiasdiou"
HorspoolMatching（pattern,text）;
关于BruteForce算法,Horspool算法的比较：
蛮力算法就是简单地从左到右比较模式和文本中的每一个对相应的字符，如果一旦不匹配，就把模式向右移动一格，在进行下一轮尝试。
这种尝试的最大次数是n-m+1次，所以这使得蛮力算法的最差性能是Θ（nm）的类型。
平均效率是Θ（n）。
Horspool算法的最差效率是Θ（nm），但对于随机文本来说，它的效率是Θ（n），但是就平均来说，Horspool算法显然要比蛮力算法快许多。
时间复杂度：
（1）BF算法就是对于主串和模式串双双自左向右，一个一个字符比较，如果不匹配，主串和模式串的位置指针都要回溯。
这样的算法时间复杂度为O（n*m），其中n和m分别为串s和串t的长度。
（2）horspool算法将主串中匹配窗口的最后一个字符跟模式串中的最后一个字符比较。
如果相等，继续从后向前对主串和模式串进行比较，直到完全相等或者在某个字符处不匹配为止（如下图中的α与σ失配）。
如果不匹配，则根据主串匹配窗口中的最后一个字符β在模式串中的下一个出现位置将窗口向右移动。
Horspool算法最坏情况下的时间复杂度是O（mn），但平均情况下它的时间复杂度是O（n）。
实验四堆的创建与堆排序
1、深刻理解变换（变治法）的思想。
堆的定义。
堆创建的算法与堆排序算法。
1、代码实现堆的创建。
2、代码实现堆排序算法。
3、分析堆排序算法的时间复杂度并与合并排序，快速排序算法进行比较，最后得出自己的结论。
实验结果（可续页）
堆的创建:
voidHeapBotttomUp（intH[],intn）;
intH[10]={11,2,3,4,5,6,7,8,9,10};
HeapBotttomUp（H,10）;
10;
%d,"
H[i]）;
voidHeapBotttomUp（intH[],intn）
intk,v;
intheap;
for（i=（n/2）;
i>
=1;
i--）
k=i;
v=H[k];
heap=0;
heap&
（2*k）<
n）
intj;
j=2*k;
if（j<
if（H[j]<
H[j+1]）
if（v>
=H[j]）
heap=1;
H[k]=H[j];
k=j;
H[k]=v;
堆排序算法代码：
voidmaxHeap（intA[],intlen,inti）
intl,r,large,temp;
l=2*i+1;
r=2*i+2;
large=i;
if（l<
len）
if（A[l]>
A[i]）
large=l;
if（r<
if（A[r]>
A[large]）
large=r;
if（large!
temp=A[large];
A[large]=A[i];
A[i]=temp;
maxHeap（A,len,large）;
voidbuildMaxHeap（intA[],intlen）
for（i=len/2-1;
=0;
maxHeap（A,len,i）;
voidmaxHeapSort（intA[],intlen）
inti,temp;
buildMaxHeap（A,len）;
建立大跟堆\n"
len;
%d"
A[i]）;
\n"
for（i=len;
1;
temp=A[0];
A[0]=A[i-1];
A[i-1]=temp;
A[i-1]）;
buildMaxHeap（A,i-1）;
intA[11]={4,1,3,2,16,9,10,14,8,7,6};
maxHeapSort（A,11）;
11;
关于堆排序和快速排序算法的比较，在元素较少时，两种算法的用时是差不多一的。
但是当数据超过四百的时候，快速排序的优势就显现出来了。
快速排序的时间基本上是线性增长，堆排序的时间增长很快。
堆排序的时间复杂度：
T（n）=O（nlog2（n））。
时间复杂度为T（n）
<
=
O（n）
+（n-1）*O（log2（n）），即等于第一次构造最大堆操作加上
后面n-1次构造堆操作
，其实由于n的减小，后面的O（log2（n））中的n也会减小，所以这里用小于等于号
。
最后得到的T（n）=O（nlog2（n））。
从平均性能来说，快速排序最佳，因为所需时间最短，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。
n较大时，归并排序所需时间较堆排序省，但归并排序需要的辅助存储量更大。
教师评分：
实验五霍纳法则
（1）深刻理解变治法的思想。
霍纳法则，二进制幂
（1）代码实现霍纳法则算法。
并实现求任给一个多项式除以（x-c）的商和余数。
（2）代码实现计算
的从左至右二进制幂算法。
（3）分析霍纳法则与蛮力计算多项式的算法时间复杂度，并进行比较。
霍纳法则算法：
intHorner（int*P,intx）
inti,p;
p=P[N-1];
for（i=N-2;
p=x*p+P[i];
returnp;
从左至右二进制幂算法：
intLeftRightBinaryExponentiation（intp,inta）
intb=a/2,c[N];
inti=0;
while（b!
=0）
c[i]=a%2;
b=a/2;
i++;
a=b;
intm;
m=i;
intproduct=p;
for（i=m-2;
product=product*product;
if（c[i]==1）
product=product*p;
product）;
intP[N];
N;
P[i]）;
intx=3;
Horner（P,x））;
inta,p;
%d%d"
p,&
a）;
LeftRightBinaryExponentiation（p,a）;
这两种算法的比较：
霍纳法则的主要思想就是将底数X从将降次之后的剩余多项式里面提取出来，讲X替换为某个多项式的值，然后再对改多项式进行求解。
二进制幂的算法主要是在重复它唯一循环的时候要做一次到两次乘法，所以在计算a的n次方时，乘法的次数总是M（n）。
霍纳法则的时间复杂度是：
O（n）;
蛮力算法的时间复杂度是：
O（n2）.
为了搞清楚霍纳法则的效率有多高，我们只需要考虑一个n次多项式的第一项：
anxn。
用蛮力算法仅仅计算这一项就会需要n次乘法，但霍纳法则除了计算这一项，还计算了其他n-1项，并且仍然只使用了相同的乘法次数！
在不需要对多项式的系数进行预处理的多项式求解算法中，霍纳法则是一种最佳选择。
实验六Warshall算法和Floyed算法
⑴利用warshall算法计算有向图传递闭包和利用Floyed算法计算全部最短路径。
（2）深刻理解并掌握动态规划法的设计思想；
warshall算法与Floyed算法
⑴上机实现算法，并用计数法和计时法分别测算算法的运行时间；
⑶通过对warshall算法与Floyed算法分析对比，找出的他们的相似处。
Wallshall算法：
voidWarshall（intA[][5],intn）
intk;
for（k=1;
k<
k++）
升级会员 