第五章,,华工数据结构试卷资料,电信学院,

第五章,,华⼯数据结构试卷资料,电信学院,
习题
5.1 选择题
1、⼀维数组和线性表的区别是（ A ）。

A、前者长度固定，后者长度可变
B、后者长度固定，前者长度可变
C、两者长度均固定
D、两者长度均可变
2、设W为⼀个⼆维数组，其每个数据元素W ij占⽤6个字节，⾏下标i从0到8，列下标j从2到5，则⼆维数组W的数据元素共占⽤（C）个字节。

A、480 Ｂ、192 Ｃ、216 Ｄ、144
3、在稀疏矩阵的⾏逻辑链式存储中，每个⾏单链表中的结点都具有相同的（ A ）。

A、⾏号
B、列号Ｃ、元素值D、地址
4、⼆维数组M的元素是4个字符（每个字符占⼀个存储单元）组成的串，⾏下标i的范围从0到4，列下标j的范围从0到5，M按⾏序存储时元素M[3][5]的起始地址与M按列序存储时的元素（）的起始地址相同。

A 、M[2][4] B、M[3][4] C、M[3][5] D、M[4][4]
5、稀疏矩阵⼀般的压缩存储⽅法有两种，即（C）。

A、⼆维数组和三维数组
B、三元组和散列
C、三元组和⼗字链表
D、散列和⼗字链表
5.2 填空题
1、⼀维数组的逻辑结构是（线性表），存储结构是（顺序存储）；对于⼆维或多维数组，分为按（⾏序）和（列序）两种不同的⽅式存储。

2、对于⼀个⼆维数组A[m][n]，若按⾏序为主序存储，则任⼀元素A[i][j]相对于A[0][0]的地址为（A+(i*m+j)*每个元素所占字节数）。

3、已知⼴义表A=((a,b,c),(d,e,f))，则运算head(tail(tail(A)))=（e）。

4、三维数组R[c1‥d1,c2‥d2,c3‥d3]共含有（（d1-c1+1）*(d2-c2+1)*(d3-c3+1)）个元素。

（c1≤d1,c2≤d2,c3≤d3）
5、⼆维数组A[10‥20][5‥10]以⾏序为主序存储，每个元素占4个存储单元，且A[10][5]的存储地址是1000，则A[18][9]的地址是（1368）。

5.3 应⽤题
1、按⾏优先存储⽅式，写出三维数组A[3][2][4]在内存中的排列顺序及地址计算公式（假设每个数组元素占⽤L个字节的内存单元，a[0][0][0]的内存地址为Loc(a[0][0][0])）。

答：内存中的排列顺序为：
A[0][0][0],A[0][0][1],A[0][0][2],A[0][0][3], A[0][1][0],A[0][1][1],A[0][1][2],A[0][1][3],
A[1][0][0],A[1][0][1],A[1][0][2],A[1][0][3], A[1][1][0],A[1][1][1],A[1][1][2],A[1][1][3],
A[2][0][0],A[2][0][1],A[2][0][2],A[2][0][3], A[2][1][0],A[2][1][1],A[2][1][2],A[2][1][3]地址计算公式为：
Loc(a[i][j][k])= Loc(a[0][0][0])+（i*2*4+j*4+k）*L
2、给定矩阵A如下，写出它的三元组表⽰、⾏逻辑链式存储和⼗字链表存储。

答：三元组表⽰法：m=5,n=5,t=6,data 数组为：
下标
1 2 3 4 5 6 ┇ MaxTerms
⾏逻辑链式存储⽅式：
1
2 3 4 5
⼗字链表存储⽅式：
1 2 3 4 5
5 3、求下列⼴义表的运算的结果
（1）head((p,h,w)) 结果为：(p,h,w)
（2）tail ((b,k,p,h)) 结果为：( )
（3）head(((a,b),(c,d))) 结果为：((a,b),(c,d) )
（4）tail (((b),(c,d))) 结果为：( )
（5）head (tail (head(( (a,d),(c,d))))) 结果为：c
（6）tail (head (tail (((a,b),(c,d))))) 结果为：( )
4、求出下列⼴义表的长度和深度。

（1）A=（（））结果为：1 2
（2）B=（a，（b，（c）））结果为：2 3
（3）C=（a，（b，（c，d）），（e））结果为：3 3
（4）F=（（a，（b，（），c），（（d）,e））结果为：3 3 5、画出下列⼴义表的图形表⽰
（1）A(b,(A,a,C(A)),C(A))
（2）D(A( ),B(e),C(a,L(b,c,d)))
( 1 ) ( 2 ) 6、画出第5题的⼴义表的单链表表⽰。

答：
A
（2 ）
5.4 算法题
1、试写⼀个算法，查找⼗字链表中某⼀⾮零元素x。

#include
#include
typedef int Elemtype;
#define MaxRows 10
#define Maxcolumns 10
struct CrossNode{
int row,col;
Elemtype val;
CrossNode *down,*right;
};
struct CLMatrix {
int m,n,t;
CrossNode *rhead[MaxRows+1];
CrossNode *chead[Maxcolumns+1];
};
void create(CLMatrix &cl)
{
CrossNode *s;
printf("请输⼊稀疏矩阵的⾏数和列数：(中间以逗号隔开！)\n"); scanf("%d,%d",&cl.m,&cl.n);
for(int j=1;j<=cl.m;j++)
cl.rhead[j]=NULL;
for(int k=1;k<=cl.n;k++)
cl.chead[k]=NULL;
printf("请输⼊稀疏矩阵的⾮零元素个数：)\n");
scanf("%d",&cl.t);
printf("请输⼊⾮零元素（按⾏，列，值）：\n");
for(int i=1;i<=cl.t;i++)
{
s=(CrossNode *)malloc(sizeof(CrossNode)); scanf("%d,%d,%d",&s->row,&s->col,&s->val); s->right=cl.rhead[s->row];
cl.rhead[s->row]=s;
s->down=cl.chead[s->col];
cl.chead[s->col]=s;
}
}
void print1( CrossNode *L )
{ CrossNode *p ;
p=L;
while ( p->right )
{
printf ("%d,%d,%d\n" , p->row,p->col,p->val); p=p->right;
}
printf ("%d,%d,%d\n" , p->row,p->col,p->val); }
void print2( CrossNode *L )
{ CrossNode *p ;
p=L;
while ( p->down )
{
printf ("%d,%d,%d\n" , p->row,p->col,p->val); p=p->down;
}
printf ("%d,%d,%d\n" , p->row,p->col,p->val); }
void printcl(CLMatrix cl)
{
int n;
printf("请按提⽰输⼊：\n");
printf("按⾏序输出，请输⼊1：\n");
printf("按列序输出，请输⼊2：\n");
scanf("%d",&n);
if(n==1)
for(int i=1;i<=cl.m;i++)
{
if (cl.rhead[i]==NULL)
printf("第%d⾏⽆⾮零元素！\n",i);
else
{
printf("第%d⾏的⾮零元素为：\n",i);
print1(cl.rhead[i]);
}
}
else
for(int j=1;j<=cl.m;j++)
{
if (cl.chead[j]==NULL)
printf("第%d列⽆⾮零元素！\n",j);
else
{
printf("第%d列的⾮零元素为：\n",j);
print2(cl.chead[j]);
}
}
}
CrossNode *Locate(CrossNode *L, Elemtype elem) {
CrossNode *p=L; // p指向单链表的第⼀个结点while ( p&&p->val!= elem ) //顺序查找符合条件的结点p=p->right;
if ( p ) return p; //查找成功，返回结点的序号
else return NULL ; //查找不成功，返回0值
}
void locatelc(CLMatrix cl, Elemtype x)
{
CrossNode *p ;
for(int i=1;i<=cl.m;i++)
{
p=Locate(cl.rhead[i],x);
if(p!=NULL)
break;
}
if (p==NULL)
printf("不存在该⾮零元素！\n");
else
printf("%d,%d,%d\n" , p->row,p->col,p->val);
}
void main()
{
CLMatrix cl;
Elemtype x;
create(cl);
printf("输出创建的按⼗字链表存储的稀疏矩阵：\n");
printcl(cl);
printf("请输⼊要查找的⾮零元素的值：");
scanf("%d",&x);
locatelc(cl, x);
}
2、试编写⼀个以三元组形式输出，⽤⼗字链表表⽰的稀疏矩阵中⾮零元素及其下标的算法。

#include #include
typedef int Elemtype;
#define MaxRows 10
#define Maxcolumns 10
struct CrossNode{
int row,col;
Elemtype val;
CrossNode *down,*right;
};
struct CLMatrix {
int m,n,t;
CrossNode *rhead[MaxRows+1];
CrossNode *chead[Maxcolumns+1];
};
int x=0,y=0;
void create(CLMatrix &cl)
{
CrossNode *s;
printf("请输⼊稀疏矩阵的⾏数和列数：(中间以逗号隔开！)\n"); scanf("%d,%d",&cl.m,&cl.n); for(int j=1;j<=cl.m;j++)
cl.rhead[j]=NULL;
for(int k=1;k<=cl.n;k++)
cl.chead[k]=NULL;
printf("请输⼊稀疏矩阵的⾮零元素个数：)\n");
scanf("%d",&cl.t);
printf("请输⼊⾮零元素（按⾏，列，值）：\n");
for(int i=1;i<=cl.t;i++)
{
s=(CrossNode *)malloc(sizeof(CrossNode));
scanf("%d,%d,%d",&s->row,&s->col,&s->val);
s->right=cl.rhead[s->row];
cl.rhead[s->row]=s;
s->down=cl.chead[s->col];
cl.chead[s->col]=s;
}
}
void print1( CrossNode *L )
{ CrossNode *p ;
p=L;
while ( p->right )
{
x++;
printf("第%d个⾮零元素为：\n",x);
printf ("%d,%d,%d\n" , p->row,p->col,p->val);
}
x++;
printf("第%d个⾮零元素为：\n",x);
printf ("%d,%d,%d\n" , p->row,p->col,p->val); }
void print2( CrossNode *L )
{ CrossNode *p ;
p=L;
while ( p->down )
{
y++;
printf("第%d个⾮零元素为：\n",y);
printf ("%d,%d,%d\n" , p->row,p->col,p->val); p=p->down; }
y++;
printf("第%d个⾮零元素为：\n",y);
printf ("%d,%d,%d\n" , p->row,p->col,p->val); }
void printcl(CLMatrix cl)
{
int n;
printf("请按提⽰输⼊：\n");
printf("按⾏序输出，请输⼊1：\n");
printf("按列序输出，请输⼊2：\n");
scanf("%d",&n);
if(n==1)
for(int i=1;i<=cl.m;i++)
{
if (cl.rhead[i]!=NULL)
print1(cl.rhead[i]);
}
else
for(int j=1;j<=cl.m;j++)
if (cl.chead[j]!=NULL)
print2(cl.chead[j]);
}
void main()
{
CLMatrix cl;
printf("按三元组输出创建的稀疏矩阵：\n");
printcl(cl);
}
3、编写⼀个算法max（*GL），求出⼀个⼴义表GL中最⼤的原⼦。

例如，max（（a，（b），d，c））返回的结果为d。

4、如果矩阵A中存在这样的⼀个元素A[i][j]满⾜条件：A[i][j]是第i⾏中值最⼩的元素，且⼜是第j 列中值最⼤的元素，则称之为该矩阵的⼀个马鞍点。

编写⼀个函数计算出m*n的矩阵A的所有马鞍点。

（作为上机实践题⽬）
5、假设稀疏矩阵A和B（分别为m*n和n*l的矩阵）采⽤三元组表⽰，编写⼀个函数计算C=A*B，要求C也是采⽤三元组表⽰。

（作为上机实践题⽬）。