算法设计与分析Word文件下载.docx
《算法设计与分析Word文件下载.docx》由会员分享，可在线阅读，更多相关《算法设计与分析Word文件下载.docx（24页珍藏版）》请在冰豆网上搜索。
//存放元素的个数
//初始化函数
voidInitial（）
{
cout<
<
"
请输入元素的个数：
"
;
cin>
>
count;
请输入"
<
count<
个元素：
for（inti=0;
i<
i++）
{
g_array[i];
}
}
//合并函数
voidMerge（inta[],intl,intm,intr）
inti=l,j=m+1,k=l;
intb[N];
while（i<
=m&
&
j<
=r）
if（a[i]<
=a[j]）
b[k++]=a[i++];
else
b[k++]=a[j++];
if（i>
m）
for（intp=j;
p<
=r;
p++）
b[k++]=a[p];
for（intp=i;
=m;
//把b[]中排好的元素copy到a[]中
for（intq=l;
q<
q++）
a[q]=b[q];
//归并排序递归算法表示
voidMergeSort（inta[],intleft,intright）
if（left<
right）//数组至少要有两个元素
inti=（right+left）/2;
MergeSort（a,left,i）;
MergeSort（a,i+1,right）;
Merge（a,left,i,right）;
//把left到right的元素排序好
//打印排好序的数组
voidPrint（）
经过MergeSort后：
g_array[i]<
endl;
intmain（）
Initial（）;
if（count>
1）
MergeSort（g_array,0,count-1）;
Print（）;
elseif（count==1）
system（"
pause"
）;
return0;
}
四、实验结果：
五、实验小结：
———————————————————————————————
评语：
成绩：
批阅教师：
日期：
Countinginversions＿＿＿＿＿＿＿＿
同组人实验室时间2016.10.21
一、实验目的：
了解并掌握Countinginversions算法得思想。
测试数组{1,4,2,9,48,15,13,44,6,90}中的逆序数对。
#include<
/*归并求逆序对数,arr存储最终有序结果
*在函数外申请一个临时数组作为参数传入
*避免递归不断创建临时数组的开销
*/
intMerge（int*arr,intbeg,intmid,intend,int*tmp_arr）
memcpy（tmp_arr+beg,arr+beg,sizeof（int）*（end-beg+1））;
inti=beg;
intj=mid+1;
intk=beg;
intinversion=0;
//合并过程中的逆序数
while（i<
=mid&
=end）
if（tmp_arr[i]<
=tmp_arr[j]）
arr[k++]=tmp_arr[i++];
}else
arr[k++]=tmp_arr[j++];
inversion+=（mid-i+1）;
=mid）
while（j<
returninversion;
intMergeInversion（int*arr,intbeg,intend,int*tmp_arr）
intinversions=0;
//记录倒序数
if（beg<
end）
intmid=（beg+end）>
1;
inversions+=MergeInversion（arr,beg,mid,tmp_arr）;
inversions+=MergeInversion（arr,mid+1,end,tmp_arr）;
inversions+=Merge（arr,beg,mid,end,tmp_arr）;
returninversions;
/*测试序列：
answer:
10*/
inttestPoint[10]={
1,4,2,9,48,
15,13,44,6,90
};
voidmain（）
intarrcopy[10];
//临时数组
memcpy（arrcopy,testPoint,sizeoftestPoint）;
printf（"
thenumofinversionsis:
%d\n"
MergeInversion（testPoint,0,9,arrcopy））;
Quitsort＿＿＿＿＿＿＿＿＿＿＿
同组人实验室时间2016.10.28
了解和掌握Quitsort排序算法的思想。
利用快速排序算法的思想对一组数据进行从小到大的排序
voidquickSort（inta[],int,int）;
intmain（）
{
intarray[]={34,65,12,43,67,5,78,10,3,70},k;
intlen=sizeof（array）/sizeof（int）;
cout<
Theorginalarrayare:
endl;
for（k=0;
k<
len;
k++）
array[k]<
"
quickSort（array,0,len-1）;
Thesortedarrayare:
voidquickSort（ints[],intl,intr）
if（l<
r）
{
inti=l,j=r,x=s[l];
while（i<
j）
j&
s[j]>
=x）//从右向左找第一个小于x的数
j--;
if（i<
s[i++]=s[j];
s[i]<
x）//从左向右找第一个大于等于x的数
i++;
s[j--]=s[i];
}
s[i]=x;
quickSort（s,l,i-1）;
//递归调用
quickSort（s,i+1,r）;
Strassenalgorithm＿＿＿＿＿＿＿＿
同组人实验室时间2016.11.04
了解并掌握Strassenalgorithm算法的基本思想。
运用Strassenalgorithm算法计算两个矩阵的乘法。
//STRASSEN矩阵算法
#include<
iostream.h>
constintN=8;
//常量N用来定义矩阵的大小
voidSTRASSEN（intn,floatA[][N],floatB[][N],floatC[][N]）;
voidinput（intn,floatp[][N]）;
voidoutput（intn,floatC[][N]）;
//函数声明部分
floatA[N][N],B[N][N],C[N][N];
//定义三个矩阵A,B,C
cout<
现在录入矩阵A[N][N]:
endl<
input（N,A）;
现在录入矩阵B[N][N]:
input（N,B）;
//录入数组
STRASSEN（N,A,B,C）;
//调用STRASSEN函数计算
output（N,C）;
//输出计算结果
voidinput（intn,floatp[][N]）//矩阵输入函数
inti,j;
for（i=0;
i<
n;
i++）
请输入第"
i+1<
行"
for（j=0;
j<
j++）
cin>
p[i][j];
voidoutput（intn,floatC[][N]）//据矩阵输出函数
输出矩阵:
C[i][j]<
voidMATRIX_MULTIPLY（floatA[][N],floatB[][N],floatC[][N]）//按通常的矩阵乘法计算C=AB的子算法（仅做2阶）
inti,j,t;
2;
i++）//计算A*B-->
C
C[i][j]=0;
//计算完一个C[i][j]，C[i][j]应重新赋值为零
for（t=0;
t<
t++）
C[i][j]=C[i][j]+A[i][t]*B[t][j];
voidMATRIX_ADD（intn,floatX[][N],floatY[][N],floatZ[][N]）//矩阵加法函数X+Y—>
Z
Z[i][j]=X[i][j]+Y[i][j];
voidMATRIX_SUB（intn,floatX[][N],floatY[][N],floatZ[][N]）//矩阵减法函数X-Y—>
Z[i][j]=X[i][j]-Y[i][j];
voidSTRASSEN（intn,floatA[][N],floatB[][N],floatC[][N]）//STRASSEN函数（递归）
floatA11[N][N],A12[N][N],A21[N][N],A22[N][N];
floatB11[N][N],B12[N][N],B21[N][N],B22[N][N];
floatC11[N][N],C12[N][N],C21[N][N],C22[N][N];
floatM1[N][N],M2[N][N],M3[N][N],M4[N][N],M5[N][N],M6[N][N],M7[N][N];
floatAA[N][N],BB[N][N],MM1[N][N],MM2[N][N];
//,x;
if（n==2）
MATRIX_MULTIPLY（A,B,C）;
//按通常的矩阵乘法计算C=AB的子算法（仅做2阶）
else
n/2;
i++）//////////
A11[i][j]=A[i][j];
A12[i][j]=A[i][j+n/2];
A21[i][j]=A[i+n/2][j];
A22[i][j]=A[i+n/2][j+n/2];
B11[i][j]=B[i][j];
B12[i][j]=B[i][j+n/2];
B21[i][j]=B[i+n/2][j];
B22[i][j]=B[i+n/2][j+n/2];
}//将矩阵A和B式分为四块
MATRIX_SUB（n/2,B12,B22,BB）;
//////////
STRASSEN（n/2,A11,BB,M1）;
//M1=A11（B12-B22）
MATRIX_ADD（n/2,A11,A12,AA）;
STRASSEN（n/2,AA,B22,M2）;
//M2=（A11+A12）B22
MATRIX_ADD（n/2,A21,A22,AA）;
STRASSEN（n/2,AA,B11,M3）;
//M3=（A21+A22）B11
MATRIX_SUB（n/2,B21,B11,BB）;
STRASSEN（n/2,A22,BB,M4）;
//M4=A22（B21-B11）
MATRIX_ADD（n/2,A11,A22,AA）;
MATRIX_ADD（n/2,B11,B22,BB）;
STRASSEN（n/2,AA,BB,M5）;
//M5=（A11+A22）（B11+B22）
MATRIX_SUB（n/2,A12,A22,AA）;
MATRIX_SUB（n/2,B21,B22,BB）;
STRASSEN（n/2,AA,BB,M6）;
//M6=（A12-A22）（B21+B22）
MATRIX_SUB（n/2,A11,A21,AA）;
MATRIX_SUB（n/2,B11,B12,BB）;
STRASSEN（n/2,AA,BB,M7）;
//M7=（A11-A21）（B11+B12）
//计算M1,M2,M3,M4,M5,M6,M7（递归部分）
MATRIX_ADD（N/2,M5,M4,MM1）;
MATRIX_SUB（N/2,M2,M6,MM2）;
MATRIX_SUB（N/2,MM1,MM2,C11）;
//C11=M5+M4-M2+M6
MATRIX_ADD（N/2,M1,M2,C12）;
//C12=M1+M2
MATRIX_ADD（N/2,M3,M4,C21）;
//C21=M3+M4
MATRIX_ADD（N/2,M5,M1,MM1）;
MATRIX_ADD（N/2,M3,M7,MM2）;
MATRIX_SUB（N/2,MM1,MM2,C22）;
//C22=M5+M1-M3-M7
C[i][j]=C11[i][j];
C[i][j+n/2]=C12[i][j];
C[i+n/2][j]=C21[i][j];
C[i+n/2][j+n/2]=C22[i][j];
}//计算结果送回C[N][N]
Kargar’salgorithm＿＿＿＿＿＿＿＿
同组人实验室时间2016.11.11
掌握线型的掩码及含义，并会使用线型掩码画出虚线、点画线。
了解线粗的画法。
完成掌握线型和线粗算法并将运行结果截图写入实验报告。
algorithm>
#include"
conio.h"
structgood//表示物品的结构体
doublep;
//价值
doublew;
//重量
doubler;
//价值与重量的比
a[20];
doubles,value,m;
inti,num;
boolbigger（gooda,goodb）
returna.r>
b.r;
printf（"
\t\t---------贪心算法解决背包问题----------\n"
请输入您要输入的货物的个数:
scanf（"
%d"
&
num）;
//物品个数
请输入货物的重量与价值格式为（wp）每输入一组数据回车:
\n"
intk;
for（i=0;
num;
i++）
%lf%lf"
a[i].w,&
a[i].p）;
a[i].r=a[i].p/a[i].w;
sort（a,a+num,bigger）;
//调用sort排序函数
请输入包的容量:
%lf"
m）;
//读入包的容量m
s=0;
//包内现存货品的重量
value=0;
//包内现存货品总价值
num&
s+a[i].w<
=m;
value+=a[i].p;
s+=a[i].w;
k=i;
value+=（m-s）*a[k+1].r;
背包的最大总价值为%.2lf.\n"
value）;
//输出结果
getch（）;
Dijkstra＿＿＿＿＿＿＿＿＿＿
同组人实验室时间2016.11.18
了解并掌握Dijkstra算法的基本思想。
运用Dijkstra算法计算一个节点到其他所有节点的最短路径。
cstdio>
cstdlib>
constintmaxnum=100;
constintmaxint=999999;
//个数组下标都从1开始
intdist[maxnum];
//表示当前点到源点的最短路径长度
intprev[maxnum];
//记录当前点的前一个结点
intc[maxnum][maxnum];
//记录图的两点间路径长度
intn,line;
//图的节点数和路径数
/*
*n--nnodes
*v--thesourcenode
*dist[]--thedistancefromtheithnodetothesourcenode
*prev[]--thepreviousnodeoftheithnode
*c[][]--everytwonodes'
distance
*/
voidDijkstra（in
升级会员 