大数据结构实验报告材料.docx
《大数据结构实验报告材料.docx》由会员分享，可在线阅读，更多相关《大数据结构实验报告材料.docx（22页珍藏版）》请在冰豆网上搜索。
大数据结构实验报告材料
本科生实验报告
（二）
姓名:
学院:
专业:
班级:
实验课程名称:
数据结构
实验日期:
2013年5月25日
指导教师及职称:
实验成绩:
开课时间：
2012～2013学年第二学期
实验题目
数据结构实验
小组合作
姓名
班级
学号
3
一、实验目的
数组和广义表：
实验6.1：
求5*5阶螺旋方阵；
实验6.2：
求一个矩阵的马鞍点；
实验6.3：
求两个对称矩阵之和与乘积；
实验6.4：
实现稀疏矩阵（采用三元组表示）的基本运算；
实验6.5：
实现广义表的基本运算。
二．实验环境
计算机Visualc++6.0
三、实验内容与步骤
6.1以下是一个5*5的螺旋矩阵。
设计一个程序exp6-1.cpp输出该形式的n*n（n<10）阶方阵（顺时针方向旋进）。
12345
161718196
152425207
142322218
131211109
主程序如下：
#include"stdafx.h"
#include
#defineMaxLen10
voidfun（inta[MaxLen][MaxLen],intn）
{
inti,j,k=0,m;
if（n%2==0）//m=én/2ù
m=n/2;
else
m=n/2+1;
for（i=0;i{
for（j=i;j{
k++;
a[i][j]=k;
}
for（j=i+1;j{
k++;
a[j][n-i-1]=k;
}
for（j=n-i-2;j>=i;j--）
{
k++;
a[n-i-1][j]=k;
}
for（j=n-i-2;j>=i+1;j--）
{
k++;
[j][i]=k;
}
}
}
voidmain（）
{
intn,i,j;
inta[MaxLen][MaxLen];
printf（"输入n（n<10）:
"）;
scanf（"%d",&n）;
fun（a,n）;
printf（"%d阶数字方阵如下:
\n",n）;
for（i=0;i{
for（j=0;jprintf（"%4d",a[i][j]）;
printf（"\n"）;
}
}
运行结果：
6.2：
如果矩阵A中存在这样的一个元素A[i][j]满足条件：
A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称为该矩阵的一个马鞍点。
设计一个程序exp6-2.cpp计算出m*n的矩阵A的所有马鞍点。
主程序如下：
#include
#defineM4
#defineN4
voidMinMax（intA[M][N]）
{inti,j;
boolhave=false;
intmin[M],max[N];
for（i=0;i{
min[i]=A[i][0];
for（j=1;jif（A[i][j]min[i]=A[i][j];
}
for（j=0;j{max[j]=A[0][j];
for（i=1;iif（A[i][j]>max[j]）
max[j]=A[i][j];
}
for（i=0;ifor（j=0;jif（min[i]==max[j]）
{printf（"A[%d][%d]=%d\n",i,j,A[i][j]）;//显示马鞍点
have=true;
}
if（!
have）
printf（"没有鞍点\n"）;
}
voidmain（）
{inti,j;
intA[M][N]={{9,7,6,8},{20,26,22,25},{28,36,25,30},{12,4,2,6}};
printf（"A矩阵:
\n"）;
for（i=0;i{for（j=0;jprintf（"%4d",A[i][j]）;
printf（"\n"）;
}
printf（"A矩阵中的马鞍点:
\n"）;
MinMax（A）;//调用MinMax（）找马鞍点
}
运行结果：
6.3：
已知A和B为两个n*n阶的对称矩阵，输入时，对称矩阵只输入下三角形元素，存入一维数组，如图6.5所示（对称矩阵M存储在一维数组A中），设计一个程序exp6-3.cpp实习如下功能：
（1）求对称矩阵A和B的和。
（2）求对称矩阵A和B的乘积。
A:
图6.5对称矩阵的存储转换形式主程序如下：
#include
#defineN4
#defineM10
intvalue（inta[],inti,intj）
{
if（i>=j）
returna[（i*（i-1））/2+j];
else
returna[（j*（j-1））/2+i];
}
voidmadd（inta[],intb[],intc[][N]）
{
inti,j;
for（i=0;ifor（j=0;jc[i][j]=value（a,i,j）+value（b,i,j）;
}
voidmult（inta[],intb[],intc[][N]）
{
inti,j,k,s;
for（i=0;ifor（j=0;j{
s=0;
for（k=0;ks=s+value（a,i,k）*value（b,k,j）;
c[i][j]=s;
}
}
voiddisp1（inta[]）
{
inti,j;
for（i=0;i{
for（j=0;jprintf（"%4d",value（a,i,j））;
printf（"\n"）;
}
}
voiddisp2（intc[][N]）
{
inti,j;
for（i=0;i{
for（j=0;jprintf（"%4d",c[i][j]）;
printf（"\n"）;
}
}
voidmain（）
{
inta[M]={1,2,3,4,5,6,7,8,9,10};
intb[M]={1,1,1,1,1,1,1,1,1,1};
intc1[N][N],c2[N][N];
madd（a,b,c1）;
mult（a,b,c2）;
printf（"a矩阵:
\n"）;disp1（a）;
printf（"b矩阵:
\n"）;disp1（b）;
printf（"a+b:
\n"）;disp2（c1）;
printf（"a×b:
\n"）;disp2（c2）;
printf（"\n"）;
}
运行结果：
6.4：
：
假设n*n的稀疏矩阵A采用三元组表示，设计一个程序exp6-4.cpp实现如下功能：
（1）生成如下两个稀疏矩阵矩阵的三元组a和b:
（2）输出a转置矩阵的三元组；
（3）输出a+b的三元组；
（4）输出a*b的三元组。
主程序如下：
#include
#defineN4
typedefintElemType;
#defineMaxSize100//矩阵中非零元素最多个数
typedefstruct
{intr;//行号
intc;//列号
ElemTyped;//元素值
}TupNode;//三元组定义
typedefstruct
{introws;//行数值
intcols;//列数值
intnums;//非零元素个数
TupNodedata[MaxSize];
}TSMatrix;//三元组顺序表定义
voidCreatMat（TSMatrix&t,ElemTypeA[N][N]）
{
inti,j;
t.rows=N;t.cols=N;t.nums=0;
for（i=0;i{
for（j=0;jif（A[i][j]!
=0）
{
t.data[t.nums].r=i;t.data[t.nums].c=j;
t.data[t.nums].d=A[i][j];t.nums++;
}
}
}
voidDispMat（TSMatrixt）
{
inti;
if（t.nums<=0）
return;
printf（"\t%d\t%d\t%d\n",t.rows,t.cols,t.nums）;
printf（"\t------------------\n"）;
for（i=0;iprintf（"\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d）;
}
voidTranMat（TSMatrixt,TSMatrix&tb）
{
intp,q=0,v;//q为tb.data的下标
tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;
if（t.nums!
=0）
{
for（v=0;vfor（p=0;pif（t.data[p].c==v）
{
tb.data[q].r=t.data[p].c;
tb.data[q].c=t.data[p].r;
tb.data[q].d=t.data[p].d;
q++;
}
}
}
boolMatAdd（TSMatrixa,TSMatrixb,TSMatrix&c）
{
inti=0,j=0,k=0;
ElemTypev;
if（a.rows!
=b.rows||a.cols!
=b.cols）
returnfalse;//行数或列数不等时不能进行相加运算
c.rows=a.rows;c.cols=a.cols;//c的行列数与a的相同
while（i{
if（a.data[i].r==b.data[j].r）//行号相等时
{
if（a.data[i].c{
c.data[k].r=a.data[i].r;//将a元素添加到c中
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;i++;
}
elseif（a.data[i].c>b.data[j].c）//a元素的列号大于b元素的列号
{
c.data[k].r=b.data[j].r;//将b元素添加到c中
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
k++;j++;
}
else//a元素的列号等于b元素的列号
{
v=a.data[i].d+b.data[j].d;
if（v!
=0）//只将不为0的结果添加到c中
{
c.data[k].r=a.data[i].r;
c.data[k].c=a.data[i].c;
c.data[k].d=v;
k++;
}
i++;j++;
}
}
elseif（a.data[i].r{
c.data[k].r=a.data[i].r;//将a元素添加到c中
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;i++;
}
else//a元素的行号大于b元素的行号
{
c.data[k].r=b.data[j].r;//将b元素添加到c中
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
k++;j++;
}
c.nums=k;
}
returntrue;
}
intgetvalue（TSMatrixc,inti,intj）
{
intk=0;
while（k=i||c.data[k].c!
=j））
k++;
if（kreturn（c.data[k].d）;
else
return（0）;
}
boolMatMul（TSMatrixa,TSMatrixb,TSMatrix&c）
{
inti,j,k,p=0;
ElemTypes;
if（a.cols!
=b.rows）//a的列数不等于b的行数时不能进行相乘运算
returnfalse;
for（i=0;ifor（j=0;j{
s=0;
for（k=0;ks=s+getvalue（a,i,k）*getvalue（b,k,j）;
if（s!
=0）//产生一个三元组元素
{
c.data[p].r=i;
c.data[p].c=j;
c.data[p].d=s;
p++;
}
}
c.rows=a.rows;
c.cols=b.cols;
c.nums=p;
returntrue;
}
voidmain（）
{
ElemTypea1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};
ElemTypeb1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};
TSMatrixa,b,c;
CreatMat（a,a1）;
CreatMat（b,b1）;
printf（"a的三元组:
\n"）;DispMat（a）;
printf（"b的三元组:
\n"）;DispMat（b）;
printf（"a转置为c\n"）;
TranMat（a,c）;
printf（"c的三元组:
\n"）;DispMat（c）;
printf（"c=a+b\n"）;
MatAdd（a,b,c）;
printf（"c的三元组:
\n"）;DispMat（c）;
printf（"c=a×b\n"）;
MatMul（a,b,c）;
printf（"c的三元组:
\n"）;DispMat（c）;
}
运行结果：
6.5：
编写一个程序exp6-5.cpp，实现广义表的各种运算，并在此基础上设计一个主程序完成如下功能：
（1）建立广义表g=“（b,（b,a,（#）,d）,（（a,b）,c,（（#））））”的链式存储结构；
（2）输出广义表g的长度；
（3）输出广义表g的深度；
（4）输出广义表g的最大原子。
主程序如下：
#include
#include
typedefcharElemType;
typedefstructlnode
{inttag;//节点类型标识
union
{
ElemTypedata;
structlnode*sublist;
}val;
structlnode*link;//指向下一个元素
}GLNode;
GLNode*CreateGL（char*&s）//返回由括号表示法表示s的广义表链式存储结构
{GLNode*g;
charch=*s++;//取一个字符
if（ch!
='\0'）//串未结束判断
{g=（GLNode*）malloc（sizeof（GLNode））;//创建一个新节点
if（ch=='（'）//当前字符为左括号时
{g->tag=1;//新节点作为表头节点
g->val.sublist=CreateGL（s）;//递归构造子表并链到表头节点
}
elseif（ch=='）'）
g=NULL;//遇到'）'字符,g置为空
elseif（ch=='#'）//遇到'#'字符，表示空表
g->val.sublist=NULL;
else//为原子字符
{g->tag=0;//新节点作为原子节点
g->val.data=ch;
}
}
else//串结束,g置为空
g=NULL;
ch=*s++;//取下一个字符
if（g!
=NULL）//串未结束，继续构造兄递节点
if（ch==','）//当前字符为','
g->link=CreateGL（s）;//递归构造兄递节点
else//没有兄弟了,将兄弟指针置为NULL
g->link=NULL;
returng;//返回广义表g
}
intGLLength（GLNode*g）//求广义表g的长度
{
intn=0;
g=g->val.sublist;//g指向广义表的第一个元素
while（g!
=NULL）
{
n++;
g=g->link;
}
returnn;
}
intGLDepth（GLNode*g）//求广义表g的深度
{
intmax=0,dep;
if（g->tag==0）
return0;
g=g->val.sublist;//g指向第一个元素
if（g==NULL）//为空表时返回1
return1;
while（g!
=NULL）//遍历表中的每一个元素
{
if（g->tag==1）//元素为子表的情况
{
dep=GLDepth（g）;//递归调用求出子表的深度
if（dep>max）max=dep;//max为同一层所求过的子表中深度的最大值
}
g=g->link;//使g指向下一个元素
}
return（max+1）;//返回表的深度
}
voidDispGL（GLNode*g）//输出广义表g
{if（g!
=NULL）//表不为空判断
{//先输出g的元素
if（g->tag==0）//g的元素为原子时
printf（"%c",g->val.data）;//输出原子值
else//g的元素为子表时
{printf（"（"）;//输出'（'
if（g->val.sublist==NULL）//为空表时
printf（"#"）;
else//为非空子表时
DispGL（g->val.sublist）;//递归输出子表
printf（"）"）;//输出'）'
}
if（g->link!
=NULL）
{printf（","）;
DispGL（g->link）;//递归输出g的兄弟
}
}
}
ElemTypemaxatom（GLNode*g）//求广义表g中最大原子
{
ElemTypemax1,max2;
if（g!
=NULL）
{
if（g->tag==0）
{
max1=maxatom（g->link）;
return（g->val.data>max1?
g->val.data:
max1）;
}
else
{
max1=maxatom（g->val.sublist）;
max2=maxatom（g->link）;
return（max1>max2?
max1:
max2）;
}
}
else
return0;
}
voidmain（）
{
GLNode*g;
char*str="（b,（b,a,（#）,d）,（（a,b）,c,（（#））））";
g=CreateGL（str）;
printf（"广义表g:
"）;DispGL（g）;printf（"\n"）;
printf（"广义表g的长度:
%d\n",GLLength（g））;
printf（"广义表g的深度:
%d\n",GLDepth（g））;
printf（"最大原子:
%c\n",maxatom（g））;
}
运行结果：
四、实验过程与分析
1.通过实验6.1的学习，了解了如何求5*5阶螺旋方阵，并且方阵是建立在数组的基础上，且从中掌握了数组的基本运算如Value（A,index1,index2,…,indexd）：
A是已存在的d维数组，index1，index2，…，indexd是指定的d个下标值，且这些下标均未越界。
其运算结果是返回由上述下标指定的A中的对应；Assign（A,e,index1,index2,…,indexd）：
A是已存在的d维数组，e为元素变量，index1，index2，…
升级会员 