您的位置：360文档中心› 数据结构1800试题-第5章 数组和广义表 - 答案

数据结构1800试题-第5章 数组和广义表 - 答案

合集下载

数据结构(数组和广义表)习题与答案

数据结构(数组和广义表)习题与答案

1、以行序优先顺序存储数组A[5][5]；假定A[0][0]的地址为1000, 每个元素占4个字节，下标变量A[4][3]的地址是____。

A.1069B.1092C.1023D.1046正确答案：B2、数组a[1．．6][1．．5] （无0行0列）以列序优先顺序存储，第一个元素a[1][1]的地址为1000，每个元素占2个存储单元，则a[3][4]的地址是____。

A.1040B.1026C.1046D.1038正确答案：A3、设有一个5行4列的矩阵A，采用行序优先存储方式，A[0][0]为第一个元素，其存储地址为1000，A[2][2]的地址为1040，则A[3][0]的地址为_________。

A.1048B.1024C.1096D.1060正确答案：A4、设有一个10行10列的矩阵A，采用行序优先存储方式，存储全部数据需要400个字节的空间。

如果A[0][0]为第一个元素，其存储地址为1000，则A[3][6]的地址为_________。

A.1036B.1144C.1014D.10565、设有一个10行10列的矩阵A，采用行序优先存储方式。

如果A[0][0]为第一个元素，其存储地址为1000，A[2][3]的存储地址为1069，则存储一个元素需要的单元数是_________。

A.4B.1C.2D.3正确答案：D6、不能够对数据元素进行随机访问的物理结构是_________。

A.三元组顺序表B.对称矩阵的压缩存储C.三对角矩阵的压缩存储D.数组的顺序存储正确答案：A7、对特殊矩阵采用压缩存储的目的主要是_________。

A.表达变得简单B.去掉矩阵中的多余元素C.对矩阵元素的存储变得简单D.减少不必要的存储空间正确答案：D8、对n*n的对称矩阵进行压缩存储，需要保存的数据元素的个数是_________。

A.nB.n(n+1)/2C.n2D.n(n+1)9、设10*10的对称矩阵下三角保存SA[1．．55]中，其中A[1][1]保存在SA[1]中，A[5][3] 保存在SA[k]中，这里k等于_________。

国开放大学数据结构(本科)单元5数组和广义表-单元测试题含答案

国开放大学数据结构(本科)单元5数组和广义表-单元测试题含答案

开放大学数据结构(本科)单元5数组和广义表单元测试题含答案试题1一维数组A采用顺序存储结构，每个元素占用4个字节，第8个元素的存储地址为120，则该数组的首地址是（）。

选择一项：A.88B.92C.32D.90反馈正确答案是：92试题2稀疏矩阵采用压缩存储的目的主要是（）。

选择一项：A.对矩阵元素的存取变得简单B.表达变得简单C.去掉矩阵中的多余元素D.减少不必要的存储空间的开销反馈正确答案是：减少不必要的存储空间的开销试题3一个非空广义表的表头（）。

选择一项：A.只能是子表B.可以是子表或原子C.不可能是原子D.只能是原子反馈正确答案是：可以是子表或原子试题4常对数组进行的两种基本操作是（）。

选择一项：A.索引与、和修改B.查找与索引C.查找和修改D.建立与删除反馈正确答案是：查找和修改试题5在二维数组A[8][10]中，每一个数组元素A[i][j] 占用3个存储空间，所有数组元素相继存放于一个连续的存储空间中，则存放该数组至少需要的存储空间是（）。

选择一项：A.80B.270C.240D.100反馈正确答案是：240试题6设有一个18阶的对称矩阵A，采用压缩存储的方式，将其下三角部分以行序为主序存储到一维数组B中（数组下标从1开始），则矩阵中元素A10,8在一维数组B 中的下标是（）。

选择一项：A.18B.53C.45D.58反馈正确答案是：53试题7广义表((a))的表尾是（）。

选择一项：A.((a))B.(a)C.0D.a反馈正确答案是：0试题8设有一个10阶的对称矩阵A，采用压缩存储的方式，将其下三角部分以行序为主序存储到一维数组B中（数组下标从1开始），则矩阵中元素A8,5在一维数组B中的下标是（）。

选择一项：A.32B.85C.41D.33反馈正确答案是：33试题9设广义表类（(a,b,c)），则L的长度和深度分别为（）。

选择一项：A.2和3B.1和2C.1和1D.1和3反馈正确答案是：1和2试题10广义表( a , a ,b , d , e ,( (i ,j ) ,k ) )的表头是________。

第四、五章串、数组和广义表练习题答案

第四、五章串、数组和广义表练习题答案

第四、五章串、数组和广义表练习题答案一．填空题1. 不包括任何字符（长度为0）的串称为空串；由一个或多个空格（仅由空格符）组成的串称为空白串。

2. 设S=“A;/document/”，那么strlen(s)= 20 , “/”的字符定位的位置为3。

3. 子串的定位运算称为串的模式匹配；被匹配的主串称为目标串，子串称为模式。

4. 设目标T=”abccdcdccbaa”，模式P=“cdcc”，那么第 6 次匹配成功。

5. 假设n为主串长，m为子串长，那么串的古典（朴素）匹配算法最坏的情形下需要比较字符的总次数为(n-m+1)*m。

6. 假设有二维数组A6×8，每一个元素用相邻的6个字节存储，存储器按字节编址。

已知A的起始存储位置（基地址）为1000，那么数组A的体积（存储量）为 288 B ；末尾元素A57的第一个字节地址为 1282 ；假设按行存储时，元素A14的第一个字节地址为(8+4)×6+1000=1072 ；假设按列存储时，元素A47的第一个字节地址为 (6×7＋4)×6＋1000）＝1276 。

(注：数组是从0行0列仍是从1行1列计算起呢？由末单元为A57可知，是从0行0列开始！)7. 〖00年运算机系考研题〗设数组a[1…60, 1…70]的基地址为2048，每一个元素占2个存储单元，假设以列序为主序顺序存储，那么元素a[32,58]的存储地址为8950 。

答：不考虑0行0列，利用列优先公式：LOC(a ij)=LOC(a c1，c2)+[(j-c2)*(d1-c1+1)+i-c1)]*L得：LOC(a32,58)=2048+[(58-1)*(60-1+1)+32-1]]*2＝89508. 三元素组表中的每一个结点对应于稀疏矩阵的一个非零元素，它包括有三个数据项，别离表示该元素的行下标、列下标和元素值。

9.求以下广义表操作的结果：（1）GetHead【((a,b),(c,d))】=== (a, b) ; u=;(*b).nu=;(*b).tu=;if{ q=1;for(col=1; __ col<=, ________;col++)for(p=1;p<=;p++)if[p].j ==col){(*b).data[q].i=[p].j;(*b).data[q].j=[p].i;(*b).data[q].v=[p].v;__q++_________;}}23．基于三元组的稀疏矩阵转置的处置方式有两种，以下计算依照矩阵A的三元组的顺序进行转置，请在___________处用适当的句子用以填充。

数据结构-5 数组与广义表

数据结构-5 数组与广义表

第五章数组与广义表一．单项选择题1．在以下的叙述中，正确的是。

A. 线性表的线性存储结构优于链表存储结构B. 二维数组是数据元素为线性表的线性表C. 栈的操作方式是先进先出D. 队列的操作方式是先进后出2．常对数组进行的两种操作是。

A. 建立与删除B. 索引和修改C. 查找和修改D. 查找与索引3．在数组A中，每个数组元素A[i,j]占用3个存储字，行下标i从1到8，列下标j从1到10。

所有数组元素相继存放在一个连续的存储空间，则存放该数组至少需要的存储字数是。

A. 80B. 100C. 240D. 2704．假设8行10列的二维数组a[1..8, 1..10]分别以行序为主序和以列序为主序顺序存储时，其首地址相同，那么以行序为主序时元素a[3][5]的地址与以列序为主序时元素 _______的地址相同。

A. a[5][3]B. a[8][3]C. a[1][4]D. 答案A、B、C均不对5．如果只保存一个n阶对称矩阵a的下三角元素（含对角线元素），并采用行主序存储在一维数组b中，a[i][j]（或a[i,j]）存于b[k]，则对i<j，下标k与i、j的关系是_____。

A. B. C. D.6．将一个A[1..100,1..100]的三对角矩阵以行序为主序存入一维数组B[1..298]中，元素A[66，65]在B数组中的位置k等于_______。

A. 198B. 197C. 196D. 1957．稀疏矩阵一般的压缩存储方法有两种，即。

A. 二维数组和三维数组B. 三元组和散列C. 三元组和十字链表D. 散列和十字链表8. 一个非空广义表的表头_______。

A. 不可能是子表B. 只能是子表C. 只能是原子D. 可以是原子或子表9. 对广义表，通常采用的存储结构是______。

A. 数组B. 链表C. Hash表D. 三元组10. 一个三元组表用于表示一个_______。

A. 线性表B. 广义表C. 双向链表D. 稀疏矩阵11．广义表G=(a,b,(c,d,(e,f)),G)的长度是。

数据结构1800试题-第5章 数组和广义表 - 答案

数据结构1800试题-第5章 数组和广义表 - 答案

第五章数组和广义表答案部分答案解释如下。

1. 错误。

对于完全二叉树，用一维数组作存储结构是效率高的（存储密度大）。

4. 错误。

数组是具有相同性质的数据元素的集合，数据元素不仅有值，还有下标。

因此，可以说数祖是元素值和下标构成的偶对的有穷集合。

5. 错误。

数组在维数和界偶确定后，其元素个数已经确定，不能进行插入和删除运算。

6. 错误。

稀疏矩阵转置后，除行列下标及行列数互换外，还必须确定该元素转置后在新三元组中的位置。

8. 错误。

广义表的取表尾运算，是非空广义表除去表头元素，剩余元素组成的表，不可能是原子。

9. 错误。

广义表的表头就是广义表的第一个元素。

只有非空广义表才能取表头。

10. 错误。

广义表中元素可以是原子，也可以是表（包括空表和非空表）。

11. 错误。

广义表的表尾，指去掉表头元素后，剩余元素所组成的表。

三、填空题1. 顺序存储结构2.（1）9572（2）12283.（1）9174（2）87884. 11005. 1164 公式：LOC(a ijk)=LOC(a000)+[v2*v3*(i-c1)+v3*(j-c2)+(k-c3)]*l (l为每个元素所占单元数)6. 2327. 13408. 11969. 第1行第3列10. (1)270 (2)27 (3)2204 11. i(i-1)/2+j (1<=i,j<=n)12. (1)n(n+1)/2 (2)i(i+1)/2 (或j(j+1)/2) (3)i(i-1)/2+j (4)j(j-1)/2+i (1<=i,j<=n)13. 1038 三对角矩阵按行存储：k=2(i-1)+j (1<=i,j<=n)14. 33 (k=i(i-1)/2+j) (1<=i,j<=n)15. 非零元很少(t<<m*n)且分布没有规律 16. 节省存储空间。

17. 上三角矩阵中，主对角线上第r(1≤r≤n) 行有n-r+1个元素，a ij所在行的元素数是j-i+1。

数据结构练习_第五章_数组和广义表

数据结构练习_第五章_数组和广义表

阵中下三角部分的元素存入一维数组B[ ]中，A[0][0]存入B[0]中，则
A[8][5]在B[ ]中（ ）位置。
A．32
B．33
C．41
D．65
12．设有一个10阶的对称矩阵A，采用压缩存储方式，以行序为主存
储，a11为第一元素，其存储地址为1，每个元素占一个地址空间，则a85
的地址为( B )。
义表
C. 广义表难以用顺序存储结构
D. 广义表可以是一个多层次
的结构
【解答】A
二、填空题
1．设有一个n阶的下三角矩阵A，如果按照行的顺序将下三角矩阵中的 元素（包括对角线上元素）存放在n(n+1)个连续的存储单元中，则A[i] [j]与A[0][0]之间有_______个数据元素。i(i+1)/2+j-1 2．从一维数组a[n]中顺序查找出一个最大值元素的时间复杂度为 ________，输出一个二维数组b[m][n]中所有元素值的时间复杂度为 ________。O(n)、O(m*n) 3．在稀疏距阵所对应的三元组线形表中，每个三元组元素按 ____________为主序，__________为辅序的次序排列。行号，列号 4．在广义表的存储结构中，单元素结点与表元素结点有一个域对应不
B. 1180
C. 1205
D. 1210
15．若6行5列的数组以列序为主序顺序存储，基地址为1000，每个元素
占2个存储单元，则第3行第4列的元素（假定无第0行第0列）的地址是
(A)。
A. 1040 B. 1042
C. 1026
D.备选答案A，B，C都不
对Leabharlann 16．稀疏矩阵一般的压缩存储方法有两种，即( C )。
9．在稀疏矩阵的带行指针向量的链接存储中，每个行单链表中的结点

完整word版数据结构数组和广义表习题及答案

完整word版数据结构数组和广义表习题及答案

习题五数组和广义表一、单项选择题1．常对数组进行的两种基本操作是（）A.建立与删除B. 索引与修改C. 查找与修改D. 查找与索引2．对于C语言的二维数组DataType A[m][n],每个数据元素占K个存储单元，二维数组中任意元素a[i,j] 的存储位置可由( )式确定.A.Loc[i,j]=A[m,n]+[(n+1)*i+j]*kB.Loc[i,j]=loc[0,0]+[(m+n)*i+j]*kC.Loc[i,j]=loc[0,0]+[(n+1)*i+j]*kD.Loc[i,j]=[(n+1)*i+j]*k3．稀疏矩阵的压缩存储方法是只存储 ( )A.非零元素B. 三元祖（i,j, aij）C. aijD. i,j4. 数组A[0..5,0..6]的每个元素占五个字节，将其按列优先次序存储在起始地址为1000的内存单元中，则元素A[5，5]的地址是( )。

A. 1175B. 1180C. 1205D. 12105. A[N，N]是对称矩阵，将下面三角（包括对角线）以行序存储到一维数组T[N（N+1）/2]中，则对任一上三角元素a[i][j]对应T[k]的下标k是（）。

A. i（i-1）/2+jB. j（j-1）/2+iC. i（j-i）/2+1D. j（i-1）/2+16. 用数组r存储静态链表，结点的next域指向后继，工作指针j指向链中结点，使j 沿链移动的操作为( )。

A. j=r[j].nextB. j=j+1C. j=j->nextD. j=r[j]-> next7. 对稀疏矩阵进行压缩存储目的是（）。

A．便于进行矩阵运算 B．便于输入和输出C．节省存储空间 D．降低运算的时间复杂度8. 已知广义表LS＝((a,b,c),(d,e,f)),运用head和tail函数取出LS中原子e的运算是( )。

A. head(tail(LS))B. tail(head(LS))C. head(tail(head(tail(LS)))D. head(tail(tail(head(LS))))9. 广义表（（a,b,c,d））的表头是（），表尾是（）。

数据结构(c语言版)题集答案——第五章_数组和广义表

数据结构(c语言版)题集答案——第五章_数组和广义表

第五章数组和广义表5.18void RSh(int A[n],int k)//把数组A的元素循环右移k位,只用一个辅助存储空间{for(i=1;i<=k;i++)if(n%i==0&&k%i==0) p=i;//求n和k的最大公约数pfor(i=0;i{j=i;l=(i+n-k)%n;temp=A[i];while(l!=i){A[j]=A[l];j=l;l=(j+n-k)%n;}// 循环右移一步A[j]=temp;}//for}//RSh分析:要把A的元素循环右移k位,则A[0]移至A[k],A[k]移至A[2k]......直到最终回到A[0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以A[0],A[1],...A[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个"循环链"上面.举例如下:n=15,k=6,则p=3.第一条链:A[0]->A[6],A[6]->A[12],A[12]->A[3],A[3]->A[9],A[9]->A[0].第二条链:A[1]->A[7],A[7]->A[13],A[13]->A[4],A[4]->A[10],A[10]->A[1].第三条链:A[2]->A[8],A[8]->A[14],A[14]->A[5],A[5]->A[11],A[11]->A[2].恰好使所有元素都右移一次.虽然未经数学证明,但作者相信上述规律应该是正确的.5.19void Get_Saddle(int A[m][n])//求矩阵A中的马鞍点{for(i=0;i{for(min=A[i][0],j=0;jif(A[i][j]for(j=0;jif(A[i][j]==min) //判断这个(些)最小值是否鞍点{for(flag=1,k=0;kif(minif(flag)printf("Found a saddle element!\nA[%d][%d]=%d",i,j,A[i][j]);}}//for}//Get_Saddle5.20int exps[MAXSIZE]; //exps数组用于存储某一项的各变元的指数int maxm,n; //maxm指示变元总数,n指示一个变元的最高指数void Print_Poly_Descend(int *a,int m)//按降幂顺序输出m元多项式的项，各项的系数已经按照题目要求存储于m维数组中，数组的头指针为a{maxm=m;for(i=m*n;i>=0;i--) //按降幂次序,可能出现的最高项次数为mnGet_All(a,m,i,0); //确定并输出所有次数为i的项}//Print_Poly_Descendvoid Get_All(int *a,int m,int i,int seq)//递归求出所有和为i的m个自然数{if(seq==maxm) Print_Nomial(a,exps); //已经求完时,输出该项else{min=i-(m-1)*n; //当前数不能小于minif(min<0) min=0;max=nfor(j=min;j<=max;j++){exps[seq]=j; //依次取符合条件的数Get_All(a,m-1,i-j,seq+1); //取下一个数}}//elseexps[seq]=0; //返回}//Get_Allvoid Print_Nomial(int *a,int exps[ ])//输出一个项,项的各变元的指数已经存储在数组exps中{pos=0;for(i=0;i{pos*=n;pos+=exps[i];}coef=*(a+pos); //取得该系数coefif(!coef) return; //该项为0时无需输出else if(coef>0) printf("+"); //系数为正时打印加号else if(coef<0) printf("-"); //系数为负时打印减号if(abs(coef)!=1) printf("%d",abs(coef)); //当系数的绝对值不为1时打印系数for(i=0;iif(exps[i]) //打印各变元及其系数{printf("x");printf("%d",i);printf("E");if(exps[i]>1) printf("%d",exp[i]); //系数为1时无需打印}}//Print_Nomial分析:本算法的关键在于如何按照降幂顺序输出各项.这里采用了一个递归函数来找到所有满足和为i的m个自然数作为各变元的指数.只要先取第一个数为j,然后再找到所有满足和为i-j的m-1个自然数就行了.要注意j的取值范围必须使剩余m-1个自然数能够找到,所以不能小于i-(m-1)*maxn,也不能大于i.只要找到了一组符合条件的数,就可以在存储多项式系数的数组中确定对应的项的系数的位置,并且在系数不为0时输出对应的项.5.21void TSMatrix_Add(TSMatrix A,TSMatrix B,TSMatrix &C)//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for(x=1;x<=A.mu;x++) //对矩阵的每一行进行加法{while(A.data[pa].iwhile(B.data[pb].iwhile(A.data[pa].i==x&&B.data[pb].i==x)//行列值都相等的元素{if(A.data[pa].j==B.data[pb].j){ce=A.data[pa].e+B.data[pb].e;if(ce) //和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelse if(A.data[pa].j>B.data[pb].j){C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile(A.data[pa]==x) //插入A中剩余的元素(第x行){C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while(B.data[pb]==x) //插入B中剩余的元素(第x行){C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22void TSMatrix_Addto(TSMatrix &A,TSMatrix B)//将三元组矩阵B加到A上{for(i=1;i<=A.tu;i++)A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for(x=1;x<=A.mu;x++) //对矩阵的每一行进行加法{while(A.data[pa].iwhile(B.data[pb].iwhile(A.data[pa].i==x&&B.data[pb].i==x)//行列值都相等的元素{if(A.data[pa].j==B.data[pb].j){ne=A.data[pa].e+B.data[pb].e;if(ne) //和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelse if(A.data[pa].j>B.data[pb].j){A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile(A.data[pa]==x) //插入A中剩余的元素(第x行){A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while(B.data[pb]==x) //插入B中剩余的元素(第x行){A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for(i=A.tu;i}//TSMatrix_Addto5.23typedef struct{int j;int e;} DSElem;typedef struct{DSElem data[MAXSIZE];int cpot[MAXROW];//这个向量存储每一行在二元组中的起始位置int mu,nu,tu;} DSMatrix; //二元组矩阵类型Status DSMatrix_Locate(DSMatrix A,int i,int j,int &e)//求二元组矩阵的元素A[i][j]的值e {for(s=A.cpot[i];sif(s{e=A.data[s];return OK;}return ERROR;}//DSMatrix_Locate5.24typedef struct{int seq; //该元素在以行为主序排列时的序号int e;} SElem;typedef struct{SElem data[MAXSIZE];int mu,nu,tu;} SMatrix; //单下标二元组矩阵类型Status SMatrix_Locate(SMatrix A,int i,int j,int &e)//求单下标二元组矩阵的元素A[i][j]的值e {s=i*A.nu+j+1;p=1;while(A.data[p].seqif(A.data[p].seq==s) //找到了元素A[i][j]{e=A.data[p].e;return OK;}return ERROR;}//SMatrix_Locate5.25typedef enum{0,1} bool;typedef struct{int mu,nu;int elem[MAXSIZE];bool map[mu][nu];} BMMatrix; //用位图表示的矩阵类型void BMMatrix_Add(BMMatrix A,BMMatrix B,BMMatrix &C)//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for(i=0;ifor(j=0;j{if(A.map[i][j]&&B.map[i][j]&&(A.elem[pa]+B.elem[pb]))//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}else if(A.map[i][j]&&!B.map[i][j]){C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}else if(!A.map[i][j]&&B.map[i][j]){C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26void Print_OLMatrix(OLMatrix A)//以三元组格式输出十字链表表示的矩阵{for(i=0;i{if(A.rhead[i])for(p=A.rhead[i];p;p=p->right) //逐次遍历每一个行链表printf("%d %d %d\n",i,p->j,p->e;}}//Print_OLMatrix5.27void OLMatrix_Add(OLMatrix &A,OLMatrix B)//把十字链表表示的矩阵B加到A上{for(j=1;j<=A.nu;j++) cp[j]=A.chead[j]; //向量cp存储每一列当前最后一个元素的指针for(i=1;i<=A.mu;i++){pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while(pb){if(pa==NULL||pa->j>pb->j) //新插入一个结点{p=(OLNode*)malloc(sizeof(OLNode));if(!pre) A.rhead[i]=p;else pre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e; //插入行链表中if(!A.chead[p->j]){A.chead[p->j]=p;p->down=NULL;}else{while(cp[p->j]->down) cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p; //插入列链表中}//ifelse if(pa->jj){pre=pa;pa=pa->right;} //pa右移一步else if(pa->e+pb->e){pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;} //直接相加else{if(!pre) A.rhead[i]=pa->right;else pre->right=pa->right;p=pa;pa=pa->right; //从行链表中删除if(A.chead[p->j]==p)A.chead[p->j]=cp[p->j]=p->down;else cp[p->j]->down=p->down; //从列链表中删除free (p);}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28void MPList_PianDao(MPList &L)//对广义表存储结构的多元多项式求第一变元的偏导{for(p=L->hp->tp;p&&p->exp;pre=p,p=p->tp){if(p->tag) Mul(p->hp,p->exp);else p->coef*=p->exp; //把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if(p) free (p); //删除可能存在的常数项}//MPList_PianDaovoid Mul(MPList &L,int x)//递归算法,对多元多项式L乘以x{for(p=L;p;p=p->tp){if(!p->tag) p->coef*=x;else Mul(p->hp,x);}}//Mul5.29void MPList_Add(MPList A,MPList B,MPList &C)//广义表存储结构的多项式相加的递归算法{C=(MPLNode*)malloc(sizeof(MPLNode)); if(!A->tag&&!B->tag) //原子项,可直接相加{C->coef=A->coef+B->coef;if(!C->coef){free(C);C=NULL;}}//ifelse if(A->tag&&B->tag) //两个多项式相加{p=A;q=B;pre=NULL;while(p&&q){if(p->exp==q->exp){C=(MPLNode*)malloc(sizeof(MPLNode)); C->exp=p->exp;MPList_Add(A->hp,B->hp,C->hp);pre->tp=C;pre=C;p=p->tp;q=q->tp;}else if(p->exp>q->exp){C=(MPLNode*)malloc(sizeof(MPLNode)); C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=(MPLNode*)malloc(sizeof(MPLNode)); C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile(p){C=(MPLNode*)malloc(sizeof(MPLNode)); C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while(q){C=(MPLNode*)malloc(sizeof(MPLNode));C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;} //将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//else ifelse if(A->tag&&!B->tag) //多项式和常数项相加{x=B->coef;for(p=A;p->tp->tp;p=p->tp);if(p->tp->exp==0) p->tp->coef+=x; //当多项式中含有常数项时,加上常数项if(!p->tp->coef){free(p->tp);p->tp=NULL;}else{q=(MPLNode*)malloc(sizeof(MPLNode));q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;} //否则新建常数项,下同}//else ifelse{x=A->coef;for(p=B;p->tp->tp;p=p->tp);if(p->tp->exp==0) p->tp->coef+=x;if(!p->tp->coef){free(p->tp);p->tp=NULL;}else{q=(MPLNode*)malloc(sizeof(MPLNode));q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30int GList_Getdeph(GList L)//求广义表深度的递归算法{if(!L->tag) return 0; //原子深度为0else if(!L) return 1; //空表深度为1m=GList_Getdeph(L->ptr.hp)+1;n=GList_Getdeph(L->ptr.tp);return m>n?m:n;}//GList_Getdeph5.31void GList_Copy(GList A,GList &B)//复制广义表的递归算法{if(!A->tag) //当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else //当结点为子表时{B->tag=1;if(A->ptr.hp){B->ptr.hp=malloc(sizeof(GLNode));GList_Copy(A->ptr.hp,B->ptr.hp);} //复制表头if(A->ptr.tp){B->ptr.tp=malloc(sizeof(GLNode));GList_Copy(A->ptr.tp,B->ptr.tp);} //复制表尾}//else}//GList_Copy5.32int GList_Equal(GList A,GList B)//判断广义表A和B是否相等,是则返回1,否则返回0 { //广义表相等可分三种情况:if(!A&&!B) return 1; //空表是相等的if(!A->tag&&!B->tag&&A->atom==B->atom) return 1;//原子的值相等if(A->tag&&B->tag)if(GList_Equal(A->ptr.hp,B->ptr.hp)&&GList_Equal(A->ptr.tp,B->ptr.tp))return 1; //表头表尾都相等return 0;}//GList_Equal5.33void GList_PrintElem(GList A,int layer)//递归输出广义表的原子及其所在层次,layer表示当前层次{if(!A) return;if(!A->tag) printf("%d %d\n",A->atom,layer);else{GList_PrintElem(A->ptr.hp,layer+1);GList_PrintElem(A->ptr.tp,layer); //注意尾表与原表是同一层次}}//GList_PrintElem5.34void GList_Reverse(GList A)//递归逆转广义表A{GLNode *ptr[MAX_SIZE];if(A->tag&&A->ptr.tp) //当A不为原子且表尾非空时才需逆转{for(i=0,p=A;p;p=p->ptr.tp,i++){if(p->ptr.hp) GList_Reverse(p->ptr.hp); //逆转各子表ptr[i]=p->ptr.hp;}for(p=A;p;p=p->ptr.tp) //重新按逆序排列各子表的顺序p->ptr.hp=ptr[--i];}}//GList_Reverse5.35Status Create_GList(GList &L)//根据输入创建广义表L,并返回指针{scanf("%c",&ch);if(ch==' '){L=NULL;scanf("%c",&ch);if(ch!=')') return ERROR;return OK;}L=(GList)malloc(sizeof(GLNode));L->tag=1;if(isalphabet(ch)) //输入是字母{p=(GList)malloc(sizeof(GLNode)); //建原子型表头p->tag=0;p->atom=ch;L->ptr.hp=p;}else if(ch=='(') Create_GList(L->ptr.hp); //建子表型表头else return ERROR;scanf ("%c",&ch);if(ch==')') L->ptr.tp=NULL;else if(ch==',') Create_GList(L->ptr.tp); //建表尾else return ERROR;return OK;}//Create_GList分析:本题思路见书后解答.5.36void GList_PrintList(GList A)//按标准形式输出广义表{if(!A) printf("()"); //空表else if(!A->tag) printf("%d",A->atom);//原子else{printf("(");for(p=A;p;p=p->ptr.tp){GList_PrintList(p->ptr.hp);if(p->ptr.tp) printf(","); //只有当表尾非空时才需要打印逗号}printf(")");}//else}//GList_PrintList5.37void GList_DelElem(GList &A,int x)//从广义表A中删除所有值为x的原子{if(A&&A->ptr.hp){if(A->ptr.hp->tag) GList_DelElem(A->ptr.hp,x);else if(!A->ptr.hp->tag&&A->ptr.hp->atom==x){q=A;A=A->ptr.tp; //删去元素值为x的表头free(q);GList_DelElem(A,x);}}if(A&&A->ptr.tp) GList_DelElem(A->ptr.tp,x);}//GList_DelElem5.39void GList_PrintElem_LOrder(GList A)//按层序输出广义表A中的所有元素{InitQueue(Q);for(p=L;p;p=p->ptr.tp) EnQueue(Q,p);while(!QueueEmpty(Q)){DeQueue(Q,r);if(!r->tag) printf("%d",r->atom);elsefor(r=r->ptr.hp;r;r=r->ptr.tp) EnQueue(Q,r);}//while}//GList_PrintElem_LOrder分析:层序遍历的问题,一般都是借助队列来完成的,每次从队头取出一个元素的同时把它下一层的孩子插入队尾.这是层序遍历的基本思想.。

第5章数组和广义表答案

第5章数组和广义表答案

第5章数组和⼴义表答案第五章答案5.2设有三对⾓矩阵A n×n,将其三条对⾓线上的元素逐⾏的存于数组B[1..3n-2]中，使得B[k]=a ij，求：（1）⽤i,j表⽰k的下标变换公式；（2）⽤k表⽰i、j的下标变换公式。

【解答】（1）k=2(i-1)+j(2) i=[k/3]+1, j=[k/3]+k%3 （[ ]取整，%取余）5.4在稀疏矩阵的快速转置算法5.2中，将计算position[col]的⽅法稍加改动，使算法只占⽤⼀个辅助向量空间。

【解答】算法（⼀）FastTransposeTSMatrix(TSMartrix A, TSMatrix *B){/*把矩阵A转置到B所指向的矩阵中去，矩阵⽤三元组表表⽰*/int col,t,p,q;int position[MAXSIZE];B->len=A.len; B->n=A.m; B->m=A.n;if(B->len>0){position[1]=1;for(t=1;t<=A.len;t++)position[A.data[t].col+1]++; /*position[col]存放第col-1列⾮零元素的个数, 即利⽤pos[col]来记录第col-1列中⾮零元素的个数*/ /*求col列中第⼀个⾮零元素在B.data[ ]的位置，存放在position[col]中*/ for(col=2;col<=A.n;col++)position[col]=position[col]+position[col-1];for(p=1;p{col=A.data[p].col;q=position[col];B->data[q].row=A.data[p].col;B->data[q].col=A.data[p].row;B->data[q].e=A.data[p].e;Position[col]++;}}}算法(⼆)FastTransposeTSMatrix(TSMartrix A, TSMatrix *B){int col,t,p,q;int position[MAXSIZE];B->len=A.len; B->n=A.m; B->m=A.n;if(B->len>0){for(col=1;col<=A.n;col++)position[col]=0;for(t=1;t<=A.len;t++)position[A.data[t].col]++; /*计算每⼀列的⾮零元素的个数*//*从最后⼀列起求每⼀列中第⼀个⾮零元素在B.data[]中的位置，存放在position[col]中*/ for(col=A.n,t=A.len;col>0;col--) { t=t-position[col];position[col]=t+1;}for(p=1;p{col=A.data[p].col;q=position[col];B->data[q].row=A.data[p].col;B->data[q].col=A.data[p].row;B->data[q].e=A.data[p].e;Position[col]++;}}}5.6画出下⾯⼴义表的两种存储结构图⽰：((((a), b)), ((( ), d), (e, f)))【解答】第⼀种存储结构第⼆种存储结构5.7求下列⼴义表运算的结果：（1）HEAD[((a,b),(c,d))]; (a,b) （2）TAIL[((a,b),(c,d))]; ((c,d)) （3）TAIL[HEAD[((a,b),(c,d))]]; (b)（4）HEAD[TAIL[HEAD[((a,b),(c,d))]]]; b（5）TAIL[HEAD[TAIL[((a,b),(c,d))]]]; (d)。

《第5章 数组和广义表》习题解答

《第5章 数组和广义表》习题解答
returnA.base[off];
}
4．根据下标(script)修改数组元素的操作
操作int Assign(Array& A,int* script,EType e)的作用是，根据下标向量script修改数组A中相应元素的值为e。如果下标合理返回1表示修改成功，否则返回0表示操作失败。
int Assign(Array& A,int* script,EType e)
void Arrayoutput(Array A)
{int s[3],i,len=1;
switch(A.dim)
{
case 1://按一维数组格式输出
for(s[0]=0;s[0]<A.bounds[0];s[0]++) cout<<Value(A,s)<<" ";
cout<<endl;
break;
该存储结构以最右面的下标为主序，左下标优先变化，即下标变化顺序是从左到右。
以二维数组：
为例，其内存结构如图5.2（a）所示。
对于三维数组： （有2页、2行、3列），按右下标为主序的内存结构如图5.2（b）所示。
2．左下标为主序存储的n维数组中的元素a(j0,j1,...,jn-1)的地址计算公式
对于一个已经被定义的二维数组Ab0×b1=(a[i][j])b0×b1，只要给出该数组存放的起始地址LOC(a[0][0])、数组元素的行下标i和列下标j，以及每个元素所占用的存储单元（字节）数L，便可以求得元素a[i][j]在内存中的首地址LOC(a[i][j])。
int Value(Array A,int* script,EType &e)

数据结构1800试题 第5章 数组和广义表

数据结构1800试题 第5章 数组和广义表

数据结构1800试题第5章数组和广义表数据结构1800试题-第5章数组和广义表一、多项选择题1.设有一个10阶的对称矩阵a，采用压缩存储方式，以行序为主存储，a11为第一元素，其存储地址为1，每个元素占一个地址空间，则a85的地址为（）。

【燕山大学2001一、2（2分）】a、 13b。

33c。

18d。

402.有一个二维数组a[1:6，0:7]每个数组元素存储有六个相邻的字节，内存按字节寻址，所以这个数组的容量是(①) 字节。

假设存储数组元素a[1，0]的第一个字节的地址为0，则存储数组a的最后一个元素的第一个字节的地址为(②). 如果按行存储，则[2，4]的第一个字节的地址为(③). 如果按列存储，则[5,7]的第一个字节的地址为(④). 一般来说(⑤), 按行存储的a[I，J]地址等于按列存储的a[J，I]地址。

备选答案：[上海海事学院1998 II，2（5分）]①-④：a．12b.66c.72d.96e.114f.120g、 156h。

234i。

276j。

282k。

283l。

二百八十八⑤：a．行与列的上界相同b.行与列的下界相同c、行和列的上限和下限相同。

D.行中的元素数与列中的元素数相同3.设有数组a[i,j]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址ba开始顺序存放，当用以列为主存放时，元素a[5，8]的存储首地址为()。

a、 ba+141b。

ba+180摄氏度。

ba+222d。

Ba+225[南京大学，1997年1，8（2分）]4.假设以行序为主序存储二维数组a=array[1..100，1..100]，设每个数据元素占2个存储单元，基地址为10，则loc[5，5]=（）。

【福州大学1998一、10(2分)】a.808b.818c.1010d.10205.数组a[0..5,0..6]的每个元素占用五个字节，并根据列优先级以1000的起始地址存储在内存单元中，则元素a[5,5]的地址为（）。

《数据结构题集》参考答案5 数组和广义表

《数据结构题集》参考答案5 数组和广义表

第五章数组和广义表5.18⑤试设计一个算法，将数组A中的元素A[0..n-1]循环右移k位，并要求只用一个元素大小的附加存储，元素移动或交换次数为O(n)。

要求实现以下函数：void Rotate(Array1D &a, int n, int k);一维数组类型Array1D的定义：typedef ElemType Array1D[MAXLEN];void Rotate(Array1D &a, int n, int k)/* a[n] contains the elements, *//* rotate them right circlely by k sits */{int i,b=n-1,m=n;int t,c=k/n,r,g,d,e;r=k-c*n;e=r;while(r!=0){g=r;d=m/r;r=m-d*r;m=g;}for(;b>n-1-m;--b){ElemType q=a[b];i=b;t=b+e-n;if(t<0){t=b+e;}while(i!=t){if(i<e){a[i]=a[i+n-e];i=i+n-e;}else{a[i]=a[i-e];i-=e;}}//whilea[t]=q;}//for}5.21④假设稀疏矩阵A和B均以三元组表作为存储结构。

试写出矩阵相加的算法，另设三元组表C存放结果矩阵。

要求实现以下函数：Status AddTSM(TSMatrix A,TSMatrix B,TSMatrix &C);/* 三元组表示的稀疏矩阵加法: C=A+B */稀疏矩阵的三元组顺序表类型TSMatrix的定义：#define MAXSIZE 20 // 非零元个数的最大值typedef struct {int i,j; // 行下标,列下标ElemType e; // 非零元素值}Triple;typedef struct {Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数}TSMatrix;Status AddTSM(TSMatrix A,TSMatrix B,TSMatrix &C)/* 三元组表示的稀疏矩阵加法: C=A+B */{if( A.mu != B.mu || A.nu != B.nu )return ERROR;C.mu=A.mu;C.nu=A.nu;C.tu=0;int pa=1;int pb=1;int pc=1;ElemType ce;int x;for(x=1;x<=A.mu;x++) //对矩阵的每一行进行加法{while(A.data[pa].i<x) pa++;while(B.data[pb].i<x) pb++;while(A.data[pa].i==x&&B.data[pb].i==x) //行列值都相等的元素{if(A.data[pa].j==B.data[pb].j){ce=A.data[pa].e+B.data[pb].e;if(ce) //和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelse if(A.data[pa].j>B.data[pb].j){C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].e;pa++;pc++;}}//whilewhile(A.data[pa].i==x) //插入A中剩余的元素(第x行) {C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].e;pa++;pc++;}while(B.data[pb].i==x) //插入B中剩余的元素(第x行) {C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;return OK;}//TSMatrix_Add5.26③试编写一个以三元组形式输出用十字链表表示的稀疏矩阵中非零元素及其下标的算法。

数据结构 第5章 数组和广义表答案

数据结构 第5章 数组和广义表答案

第五章数组和广义表一、选择题部分答案解释如下。

1. 错误。

对于完全二叉树，用一维数组作存储结构是效率高的（存储密度大）。

4. 错误。

数组是具有相同性质的数据元素的集合，数据元素不仅有值，还有下标。

因此，可以说数祖是元素值和下标构成的偶对的有穷集合。

5. 错误。

数组在维数和界偶确定后，其元素个数已经确定，不能进行插入和删除运算。

6. 错误。

稀疏矩阵转置后，除行列下标及行列数互换外，还必须确定该元素转置后在新三元组中的位置。

8. 错误。

广义表的取表尾运算，是非空广义表除去表头元素，剩余元素组成的表，不可能是原子。

9. 错误。

广义表的表头就是广义表的第一个元素。

只有非空广义表才能取表头。

10. 错误。

广义表中元素可以是原子，也可以是表（包括空表和非空表）。

11. 错误。

广义表的表尾，指去掉表头元素后，剩余元素所组成的表。

三、填空题1. 顺序存储结构2.（1）9572（2）12283.（1）9174（2）87884. 11005. 1164 公式：LOC(a ijk)=LOC(a000)+[v2*v3*(i-c1)+v3*(j-c2)+(k-c3)]*l (l为每个元素所占单元数)6. 2327. 13408. 11969. 第1行第3列10. (1)270 (2)27 (3)2204 11. i(i-1)/2+j (1<=i,j<=n)12. (1)n(n+1)/2 (2)i(i+1)/2 (或j(j+1)/2) (3)i(i-1)/2+j (4)j(j-1)/2+i (1<=i,j<=n)13. 1038 三对角矩阵按行存储：k=2(i-1)+j (1<=i,j<=n)14. 33 (k=i(i-1)/2+j) (1<=i,j<=n)15. 非零元很少(t<<m*n)且分布没有规律 16. 节省存储空间。

17. 上三角矩阵中，主对角线上第r(1≤r≤n) 行有n-r+1个元素，a ij所在行的元素数是j-i+1。

第5章数组和广义表

第5章数组和广义表

第五章习题参考答案一、简答题1．【参考答案】：数组是一组具有相同数据类型的数据集合。

数据元素按次序存储于一段地址连续的内存空间中。

可以通过下标找到存放该元素的存储地址，访问该数据元素的值。

数组中的每一个元素和下标惟一对应。

访问数组中任意指定的数据元素形式是，数组名[下标]。

举例略。

2．【参考答案】：数组是一组具有相同数据类型的数据集合。

数据元素按次序存储于一段地址连续的内存空间中。

即数组是数据元素的线性组合，类似于顺序存储结构的线性表。

3．【参考答案】：在n阶方阵A中，若元素满足下述性质：aij=aji （0≤i，j≤n-1）则称A为n阶对称矩阵。

三角矩阵是指n阶矩阵中上三角（不包括对角线）或下三角（不包括对角线）中的元素均为常数c或为0的n阶方阵。

以主对角线划分，三角矩阵有上三角和下三角两种。

在n阶矩阵A中，所有的非零元素都集中在以对角线为中心的带状区域中，则称A为n阶对角矩阵。

实质上，除了主对角线和主对角线相邻两侧的若干条对角线上的元素之外，其余元素均为零或为常数c。

稀疏矩阵压缩存储方法有两类：顺序存储结构和链式存储结构。

共同点：为了节省存储单元，可只存储非零元素，压缩零元素的存储空间；非零元素的分布一般是没有规律的；在存储非零元素的同时，还必须存储非零元素所在的行号、列号，才能惟一确定非零元素是矩阵中的哪一个元素。

稀疏矩阵中的所有非零元素构成了三元组线性表。

4．【参考答案】：一个阶数较大的m×n矩阵中，设有s个非零元素，如果s<<m×n时，则称该矩阵为稀疏矩阵。

准确的讲，在矩阵A中，有s个非零元素。

令e=s/(m×n),称e 为矩阵的稀疏因子。

通常认为e≤0.05时，称矩阵A为稀疏矩阵。

特点：非零元素分布没有规律，而且很少，远小于矩阵中的元素总个数。

采用压缩存储，节省存储空间，只存储非零元素，并且每个非零元素都需要一个三元组（i,j,aij）惟一表示。

数据结构第五章数组和广义表

数据结构第五章数组和广义表

第五章数组和广义表：习题习题一、选择题1．假设以行序为主序存储二维数组A[1．．100,1．．100]，设每个数据元素占两个存储单元，基地址为10，则LOC(A[5，5])=( )。

A. 808B. 818C. 1010D. 10202．同一数组中的元素( )。

A. 长度可以不同 B．不限 C．类型相同 D. 长度不限3．二维数组A的元素都是6个字符组成的串，行下标i的范围从0到8，列下标j的范圈从1到10。

从供选择的答案中选出应填入下列关于数组存储叙述中( )内的正确答案。

(1)存放A至少需要( )个字节。

(2)A的第8列和第5行共占( )个字节。

(3)若A按行存放，元素A[8]【5]的起始地址与A按列存放时的元素( )的起始地址一致。

供选择的答案：(1)A. 90 B. 180 C. 240 D. 270(2) A. 108 B. 114 C. 54 D. 60(3)[8][5] B. A[3][10] [5][8] [O][9]4.数组与一般线性表的区别主要是( )。

A.存储方面B.元素类型方面C.逻辑结构方面D.不能进行插入和删除运算5．设二维数组A[1．．m，1．．n]按行存储在数组B[1．．m×n]中，则二维数组元素A[i，j]在一维数组B中的下标为( )。

A. (i-l)×n+jB. (i-l)×n+j-lC．i×(j-l) D. j×m+i-l6．所谓稀疏矩阵指的是( )。

A.零元素个数较多的矩阵B.零元素个数占矩阵元素中总个数一半的矩阵C.零元素个数远远多于非零元素个数且分布没有规律的矩阵D.包含有零元素的矩阵7．对稀疏矩阵进行压缩存储的目的是( )。

A.便于进行矩阵运算B.便于输入和输出C.节省存储空间D. 降低运算的时间复杂度8．稀疏矩阵一般的压缩存储方法有两种，即( )。

A.二维数组和三维数组B.三元组和散列C.三元组和十字链表D.散列和十字链表9．有一个100×90的稀疏矩阵，非0元素有10个，设每个整型数占两字节，则用三元组表示该矩阵时，所需的字节数是( )。

数据结构课后习题答案第五章数组与广义表

数据结构课后习题答案第五章数组与广义表

第五章数组与广义表一、假设有二维数组A6*8，每个元素用相邻的6个字节存储，存储器按字节编址。

已知A的起始存储位置（基地址）为1000。

计算：1、数组A的体积（即存储量）；2、数组A的最后一个元素a57的第一个字节的地址；3、按行存储时，元素a14的第一个字节的地址；4、按列存储时，元素a47的第一个字节的地址；答案：1、（6*8）*6=2882、loc(a57)=1000+(5*8+7)*6=1282或=1000+（288-6）=12823、loc(a14)=1000+(1*8+4)*6=10724、loc(a47)=1000+(7*6+4)*6=1276二、假设按低下标(行优先)优先存储整数数组A9*3*5*8时第一个元素的字节地址是100，每个整数占四个字节。

问下列元素的存储地址是什么？（1）a0000(2)a1111(3)a3125 (4)a8247答案：（1）100（2）loc(a1111)=100+(1*3*5*8+1*5*8+1*8+1)*4=776(3) loc(a3125)=100+(3*3*5*8+1*5*8+2*8+5)*4=1784(4) loc(a8247)=100+(8*3*5*8+2*5*8+4*8+7)*4=4416五、设有一个上三角矩阵（aij）n*n,将其上三角元素逐行存于数组B[m]中，（m 充分大），使得B[k]=aij且k=f1(i)+f2(j)+c。

试推导出函数f1,f2和常数C（要求f1和f2中不含常数项）。

答：K=n+(n-1)+(n-2)+…..+(n-(i-1)+1)+j-i=(i-1)(n+(n-i+2))/2+j-i所以f1(i)=(n+1/2)i-1/2i2f2(j)=jc=-(n+1)九、已知A为稀疏矩阵，试从空间和时间角度比较采用两种不同的存储结构（二维数组和三元组表）完成∑aii运算的优缺点。

（对角线求和）解：1、二维数组For(i=1;i<=n;i++)S=s+a[i][i];时间复杂度：O（n）2、for(i=1;i<=m.tu;i++)If(a.data[k].i==a.data[k].j) s=s+a.data[k].value;时间复杂度：O（n2）二十一、当稀疏矩阵A和B均以三元组表作为存储结构时，试写出矩阵相加的算法，其结果存放在三元组表C中。

数据库系统l试题库及答案 第5章数组和广义表

数据库系统l试题库及答案 第5章数组和广义表

第5章 数组和广义表5.1数组一、填空题1. 假设有二维数组A 6×8，每个元素用相邻的6个字节存储，存储器按字节编址。

已知A 的起始存储位置（基地址）为1000，则数组A 的体积（存储量）为 ；末尾元素A 57的第一个字节地址为 。

2. 三元组表中的每个结点对应于稀疏矩阵的一个非零元素，它包含有三个数据项，分别表示该元素的 、 和 。

3. 设数组a[1…60, 1…70]的基地址为2048，每个元素占2个存储单元，若以列序为主序顺序存储，则元素a[32,58]的存储地址为 。

4. 设n 行n 列的下三角矩阵A 已压缩到一维数组B[1..n*（n+1）/2]中，若按行为主序存储，则A[i,j]对应的B 中存储位置为 。

5. 设有一个10阶对称矩阵A 采用压缩存储方式（以行为主序存储：a 11=1），则a 85 的地址为 。

6. 设下三角矩阵A 如果按行序为主序将下三角元素A i j (i ≤j)存储在一个一维数组B[1..n(n+1)/2]中，对任一个三角矩阵元素A ij ,它在数组B 中的下标为 。

二、选择题1. （ ）假设有60行70列的二维数组a[1…60, 1…70]以列序为主序顺序存储，其基地址为10000，每个元素占2个存储单元，那么第32行第58列的元素a[32,58]的存储地址为 。

A ．16902B ．16904C ．14454D ．答案A, B, C 均不对 2. （ ）对特殊矩阵采用压缩存储的目的主要是为了 。

A ．表达变得简单B ．对矩阵元素的存取变得简单C ．去掉矩阵中多余元素D ．减少不必要的存储空间3. （ ）对于n 阶对称矩阵，如果以行序或列序放入内存中，则需要 个存储单元。

A ．n(n+1)/2B ．n(n-1)/2C ． n 2D ．n 2/24. 有一个100*90的稀疏矩阵，非0元素有10个，设每个整型数占2字节，则用三元组表示该矩阵时，所需的字节数是 。

数据结构第五章数组和广义表练习及答案

数据结构第五章数组和广义表练习及答案

数据结构第五章数组和广义表练习及答案一、选择题1、设二维数组A[0..m-1][0..n-1]按行优先顺序存储在内存中，每个元素a ij占d个字节，则元素a ij的地址为（）A、LOC(a00)+(i*n+j)*dB、LOC(a00)+((i-1)*n+j-1)*dC、LOC(a00)+((j-1)*n+i-1)*dD、LOC(a00)+(j*n+i-1)*d2、已知二维数组A8*10中，元素a12的地址为1000，每个元素占2个字节，则元素a00的地址为（）A、972B、974C、976D、9783、若数组A[0..m-1][0..n-1]按列优先顺序存储，则a ij地址为（）A、LOC(a00)+j*m+iB、LOC(a00)+j*n+IC、LOC(a00)+(j-1)*n+i-1D、LOC(a00)+(j-1)*m+I-14、若下三角矩阵A n*n，按行顺序压缩存储在数组a[0..(n+1)n/2]中，则非零元素a ij的地址为（）（设每个元素占d个字节）A、LOC(a00)+((j-1)j/2+i)*dB、LOC(a00)+((i+1)i/2+j)*dC、LOC(a00)+((i-1)i/2+i-1)*dD、LOC(a00)+((i-1)i/2+j-1)*d5、设有广义表D=（a,b,D），其长度为（B），深度为（A）A、∞B、3C、2D、56、广义表A=（a），则表尾为（）A、aB、（（））C、空表D、（a）7、广义表A=((x,(a,b)),((x,(a,b)),y))，则运算head(head(tail(A)))为（）A、xB、(a,b)C、(x,(a,b))D、A8、数组A中，每个元素的长度为3个字节，行下标i从1到8，列下标j从1到10，从首地址a开始连续存放在存储器内，存放该数组至少需要的单元数为（）A、80B、100C、240D、2709、数组A中，每个元素的长度为3个字节，行下标i从1到8，列下标j从1到10，从首地址a开始连续存放在存储器内，该数组按行存放时，元素A[8][5]的起始地址为（）A、a+141B、a+144C、a+222D、a+22510、稀疏矩阵一般的压缩存储方法有两种，即（）A、二维数组和三维数组B、三元组和散列C、三元组和十字链表D、散列和十字链表11、一个广义表的表头总是一个（）A、广义表B、元素C、空表D、元素或广义表12、数组就是矩阵，矩阵就是数组，这种说法（）A、正确B、错误C、前一句对，后一句错D、后一句对二、填空题1、广义表LS=（），其长度为（0）；深度为（0）。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

第五章数组和广义表答案部分答案解释如下。

1. 错误。

对于完全二叉树，用一维数组作存储结构是效率高的（存储密度大）。

4. 错误。

数组是具有相同性质的数据元素的集合，数据元素不仅有值，还有下标。

因此，可以说数祖是元素值和下标构成的偶对的有穷集合。

5. 错误。

数组在维数和界偶确定后，其元素个数已经确定，不能进行插入和删除运算。

6. 错误。

稀疏矩阵转置后，除行列下标及行列数互换外，还必须确定该元素转置后在新三元组中的位置。

8. 错误。

广义表的取表尾运算，是非空广义表除去表头元素，剩余元素组成的表，不可能是原子。

9. 错误。

广义表的表头就是广义表的第一个元素。

只有非空广义表才能取表头。

10. 错误。

广义表中元素可以是原子，也可以是表（包括空表和非空表）。

11. 错误。

广义表的表尾，指去掉表头元素后，剩余元素所组成的表。

三、填空题1. 顺序存储结构2.（1）9572（2）12283.（1）9174（2）87884. 11005. 1164 公式：LOC(a ijk)=LOC(a000)+[v2*v3*(i-c1)+v3*(j-c2)+(k-c3)]*l (l为每个元素所占单元数)6. 2327. 13408. 11969. 第1行第3列10. (1)270 (2)27 (3)2204 11. i(i-1)/2+j (1<=i,j<=n)12. (1)n(n+1)/2 (2)i(i+1)/2 (或j(j+1)/2) (3)i(i-1)/2+j (4)j(j-1)/2+i (1<=i,j<=n)13. 1038 三对角矩阵按行存储：k=2(i-1)+j (1<=i,j<=n)14. 33 (k=i(i-1)/2+j) (1<=i,j<=n)15. 非零元很少(t<<m*n)且分布没有规律 16. 节省存储空间。

17. 上三角矩阵中，主对角线上第r(1≤r≤n) 行有n-r+1个元素，a ij所在行的元素数是j-i+1。

所以，元素在一维数组的下标k和二维数组下标关系:k=((i-1)*(2n-i+2))/2+(j-i+1)=(i-1)(2n-i)/2+j (i≤j)18. 93 19. i(i-1)/2+j 20. 线性表 21. 其余元素组成的表22. （1）原子（单元素）是结构上不可再分的，可以是一个数或一个结构；而表带结构，本质就是广义表，因作为广义表的元素故称为子表。

（2）大写字母（3）小写字母（4）表中元素的个数（5）表展开后所含括号的层数23. 深度 24.（1）（）（2）（（））（3）2 （4）225. head（head（tail（tail（head（tail（tail（A）））））））26. 表展开后所含括号的层数 27.（1）5 （2）328. head(head(tail(LS))) 29. head(tail(tail(head(tail(head(A))))))30. head(tail(head(tail(H)))) 31. (b) 32. (x,y,z) 33. (d,e)34. GetHead(GetHead(GetTail(L)))35. 本算法中，首先数组b中元素以逆置顺序放入d数组中，然后数组a和数组d的元素比较，将大者拷贝到数组c。

第一个WHILE循环到数组a或数组d结尾，第二个和第三个WHILE 语句只能执行其中的一个。

（1）b[m-i+1]（2）x:=a[i]（3）i:=i+1（4）x:=d[j]（5）j:=j+1 （6）k:=k+1（7）i<=l （8）j<=m36.（1）(i==k) return（2）i+1（3）i-1（4）i!=k本算法利用快速排序思想，找到第k个元素的位置（下标k-1因而开初有k--）。

内层do 循环以t(t=a[low])为“枢轴”找到其应在i位置。

这时若i等于k，则算法结束。

（即第一个空格处if(i==k) return)。

否则，若i<k，就在i+1至high中间去查；若i>k，则在low 到i-1间去找，直到找到i=k为止。

37.逆置广义表的递归模型如下f(LS)=上面app END(a,b)功能是将广义表a和b作为元素的广义表连接起来。

（1）(p->tag==0) //处理原子（2）h=reverse(p->val.ptr.hp) //处理表头（3）(p->val.ptr.tp) //产生表尾的逆置广义表（4）s->val.ptr.tp=t; //连接（5）q->val.ptr.hp=h //头结点指向广义表38. 本题要求将1，2，...,n*n个自然数，按蛇型方式存放在二位数组A[n][n]中。

“蛇型”方式，即是按“副对角线”平行的各对角线，从左下到右上，再从右上到左下，存放n2个整数。

对角线共2n-1条，在副对角线上方的对角线，题目中用k表示第k条对角线（最左上角k=1），数组元素x和y方向坐标之和为k+1（即题目中的i+j=k+1）。

副对角线下方第k 条对角线与第2n-k条对角线对称，其元素的下标等于其对称元素的相应坐标各加(k-n)。

（1）k<=2*n-1 //共填2*n-1条对角线（2）q=2*n-k //副对角线以下的各条对角线上的元素数（3）k%2！=0 //k为偶数时从右上到左下，否则从左下向右上填数。

（本处计算下标i和j）（4）k>=n //修改副对角线下方的下标i和j。

（5）m++；或m=m+1 //为填下个数作准备，m变化范围1..n*n。

本题解法的另一种思路见本章算法设计题第9题。

39.本题难点有二：一是如何求下一出圈人的位置，二是某人出圈后对该人的位置如何处理。

按题中要求，从第s个人开始报数，报到第m个人，此人出圈。

n个人围成一圈，可看作环状，则下个出圈人，其位置是(s+m-1)%n。

n是人数，是个变量，出圈一人减1，算法中用i表示。

对第二个问题，算法中用出圈人后面人的位置依次前移，并把出圈人的位置（下标）存放到当时最后一个人的位置（下标）。

算法最后打印出圈人的顺序。

（1）(s+m-1) MOD i //计算出圈人s1（2）s1:=i //若s1=0,说明是第i个人出圈（i%i=0）（3）s1 TO i-1 //从s1到i依次前移，使人数减1，并将出圈人放到当前最后一个位置A[i]=w。

40. 若第n件物品能放入背包，则问题变为能否再从n-1件物品中选出若干件放入背包（这时背包可放入物品的重量变为s-w[n]）。

若第n件物品不能放入背包，则考虑从n-1件物品选若干件放入背包（这时背包可放入物品仍为s）。

若最终s=0,则有一解；否则，若s<0或虽然s>0但物品数n<1,则无解。

（1）s-w[n],n-1 //Knap(s-w[n],n-1)=true（2）s,n-1 // Knap←Knap(s,n-1)四、应用题1、958 三维数组以行为主序存储，其元素地址公式为：LOC(A ijk)=LOC(A c1c2c3)+[(i-c1)V2V3+(j-c2)V3+(k-c3)]*L+1其中c i,d i是各维的下界和上界，V i=d i-c i+1是各维元素个数，L是一个元素所占的存储单元数。

2. b对角矩阵的b条对角线，在主对角线上方和下方各有⎣b/2⎦条对角线(为叙述方便，下面设a=⎣b/2⎦)。

从第1行至第a行，每行上的元素数依次是a+1,a+2,...,b-2,b-1,最后的a 行上的元素个数是 b-1，b-2,...,a+1。

中间的(n-2a )行，每行元素个数都是b。

故b条对角线上元素个数为 (n-2a)b+a*(a+b)。

存放在一维数组V[1..nb-a(b-a)]中，其下标k与元素在二维数组中下标i和j的关系为：k=3．每个元素32个二进制位，主存字长16位，故每个元素占2个字长，行下标可平移至1到11。

（1）242 （2）22 （3）s+182 （4）s+1424．1784 (公式：Loc(A ijkl)=100(基地址)+[(i-c1)v2v3v4+(j-c2)v3v4+(k-c3)v4+(l-c4)]*45. 1210+108L (LOC(A[1,3,-2])=1210+[(k-c3)v2v1+(j-c2)v1+(i-c1)]*L（设每个元素占L个存储单元）6. 数组占的存储字节数=10*9*7*4=2520；A[5,0,7]的存储地址=100+[4*9*7+2*7+5]*4=11847. 五对角矩阵按行存储，元素在一维数组中下标（从1开始）k与i,j的关系如下:k=A[15,16]是第71个元素，在向量[-10:m]中的存储位置是60 。

8．（1）540 （2）108 （3）i=3,j=10，即A[3,10] 9． k=i(i-1)/2+j 10. 稀疏矩阵A有t个非零元素，加上行数mu、列数nu和非零元素个数tu(也算一个三元组)，共占用三元组表LTMA的3(t+1)个存储单元，用二维数组存储时占用m*n个单元，只有当3(t+1)<m*n时，用LTMA表示A才有意义。

解不等式得t<m*n/3-1。

11．参见10。

12. 题中矩阵非零元素用三元组表存储，查找某非零元素时，按常规要从第一个元素开始查找，属于顺序查找，时间复杂度为O(n)。

若使查找时间得到改善，可以建立索引，将各行行号及各行第一个非零元素在数组B中的位置（下标）偶对放入一向量C中。

若查找非零元素，可先在数组C中用折半查找到该非零元素的行号，并取出该行第一个非零元素在B中的位置，再到B中顺序（或折半）查找该元素，这时时间复杂度为O(l o gn)。

13．（1）176 （2）76和108（3）28和116。

14．（1）k = 3(i-1) (主对角线左下角，即i=j+1)k = 3(i-1)+1 (主对角线上，即i=j)k = 3(i-1)+2 (主对角线上，即i=j-1)由以上三式，得 k=2(i-1)+j (1≤i,j≤n; 1≤k≤3n-2)（2）103*103-(3*103-2)15. 稀疏矩阵A采用二维数组存储时，需要n*n个存储单元，完成求Σa ii(1<=i<=n)时，由于a[i][i]随机存取，速度快。

但采用三元组表时，若非零元素个数为t，需3(t+1)个存储单元（第一个分量中存稀疏矩阵A的行数，列数和非零元素个数，以后t个分量存各非零元素的行值、列值、元素值），比二维数组节省存储单元；但在求Σa ii(1<=i<=n)时，要扫描整个三元组表，以便找到行列值相等的非零元素求和，其时间性能比采用二维数组时差。

相关文档
最新文档