第五章数组和广习题
- 格式:doc
- 大小:49.50 KB
- 文档页数:3
第五章数组和广义表答案部分答案解释如下。
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章数组与广义表一、选择题1.在以下讲述中,正确的是(B )。
A、线性表的线性存储结构优于链表存储结构B、二维数组是其数据元素为线性表的线性表C、栈的操作方式是先进先出D、队列的操作方式是先进后出2.若采用三元组压缩技术存储稀疏矩阵,只要把每个元素的行下标和列下标互换,就完成了对该矩阵的转置运算,这种观点(A )。
A、正确B、错误3.二维数组SA 中,每个元素的长度为3 个字节,行下标I 从0 到7,列下标J 从0 到9,从首地址SA 开始连续存放在存储器内,该数组按列存放时,元素A[4][7]的起始地址为(B)。
A、SA+141B、SA+180C、SA+222D、SA+2254.数组SA 中,每个元素的长度为3 个字节,行下标I 从0 到7,列下标J 从0 到9,从首地址SA 开始连续存放在存储器内,存放该数组至少需要的字节数是( C )。
A、80B、100C、240D、2705.常对数组进行的两种基本操作是(B )。
A、建立与删除B、索引和修改C、查找和修改D、查找和索引6.将一个A[15][15]的下三角矩阵(第一个元素为A[0][0]),按行优先存入一维数组B[120]中,A 中元素A[6][5]在B 数组中的位置K 为( B )。
A、19B、26C、21D、157.若广义表A 满足Head(A)=Tail(A),则A 为(B )。
A、()B、(())C、((),())D、((),(),())8.广义表((a),a)的表头是( C ),表尾是(C )。
A、aB、bC、(a)D、((a))9.广义表((a,b),c,d)的表头是( C ),表尾是(D )。
A、aB、bC、(a,b)D、(c,d)10.广义表((a))的表头是( B ),表尾是(C )。
A、aB、(a)C、()D、((a))11.广义表(a,b,c,d)的表头是(A ),表尾是(D )。
A、aB、(a)C、(a,b)D、(b,c,d)12.广义表((a,b,c,d))的表头是(C ),表尾是(B )。
数据结构第5章数组练习题数据结构-第5章--数组练习题第五章阵列一、选择题3.有一个数组a[I,J],数组中每个元素的长度是3字节,I的值是1到8,J的值是1到10。
数组从内存ba的第一个地址开始顺序存储。
当它主要按列存储时,元素a[5,8]的第一个地址是(a)。
a.ba+141b.ba+180c.ba+222d.ba+2254.假设以行序为主序存储二维数组a=array[1..100,1..100],设每个数据元素占2个存储单元,基地址为10,则loc[5,5]=(a)。
a.808b.818c.1010d.10205.数组a[0..5,0..6]的每个元素占五个字节,将其按列优先次序存储在起始地址为1000的内存单元中,则元素a[5,5]的地址是()。
1195a、 1175b。
1180摄氏度。
1205d。
一千二百一十7.将一个a[1..100,1..100]的三对角矩阵,按行优先存入一维数组b[1e298]中,a中元素a6665(即该元素下标i=66,j=65),在b数组中的位置k为()。
供选择的答案:a、 198b年。
195c年。
1972+64*3=19410. 如果行序是n阶对称矩阵A的主序,则其下三角形的元素(包括主对角线上的所有元素)存储在一维数组B[1(n(n+1))/2]中,然后在bj*(j-1)/2+ic中确定AIJ(IA.I*(I-1)/2+JB。
i*(i+1)/2+jd。
j*(j+1)/2+i11。
设a是n*n的对称矩阵,将a的对角线和对角线上方的元素按列的顺序存储在一维数组B[1..n(n+1)/2]中,并存储上述任何元素的位置AIJ(1)≤ 一、J≤ n、而我≤ J)在B中是(c)。
a、 i(i-l)/2+jb。
j(j-l)/2+ic。
j(j-l)/2+i-1d。
i(i-l)/2+j-112。
A[n,n]是一个对称矩阵。
如果下三角形(包括对角线)按行顺序存储在尺寸组t[n(n+1)/2]中,则与任何上三角形元素a[i][J]对应的t[k]的下标k为(AB)。
第五章习题参考答案一、简答题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个,设每个整型数占两字节,则用三元组表示该矩阵时,所需的字节数是( )。
第五章数组和广义表习题一、选择题1.已知广义表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))))2.若广义表A满足head(A)= tail(A),则A为。
A.()B.(())C.((),())D.((),(),())3.广义表A=(a,b,(c,d),(e,(f,g))),则下面式子Head(Tail(Head(Tail(Tail(A)))))的值为。
A.()B.(d)C.cD.d4.稀疏矩阵一般的压缩存储方法有 两种。
A.二维数组和三维数组B.三元组和散列表C.三元组和十字链表D.散列表和十字链表5.已知矩阵A是一个对称矩阵,为了节省存储,将其下三角部分按行优先存放在一维数组B[1…n(n-1)/2]中,对下三角部分中任一元素aij(i>=j)在一维数组B的下标位置k值是。
A.i(i-1)/2+j-1B. i(i-1)/2+jC. i(i+1)/2+j-1D. i(i+1)/2+j6.已知广义表L=((x,y,z),a,(u,t,w)),从L表中取出原子u的运算是。
A.head(tail(tail(L)))B.tail(head(head(tail(L))))C.head(tail(head(tail(L))))D.head(head(tail(tail(L))))7.广义表L=((a,b,c)),则L的长度和深度分别为。
A.1和1B.1和3C.1和2D.2和38. tail (head(((a,b,c,d,e))))= 。
A.aB.c,dC.D.(b,c,d,e)9.二维数组A[10…20,5…10]采用列序方式存储,每个数据元素占4个存储单元,且A[10,5]的存储地址是1000,则A[20,9]的地址是。
第五章数组和广义表一、单项选择题*1.对矩阵压缩存储是为了______。
A. 方便运算B. 节省空间C. 方便存储D. 提高运算速度*2.数组A[0..5, 0..6]的每个元素占5个单元,将其按列优先次序存储在起始地址为1000的连续内在单元中,则元素A[5][5]的地址为_______。
A. 1175B. 1180C.1205D. 12101.数据A中,每个元素A[i, j]的长度为3个字节,行下标i从1到8,列下标j从1到10,从首地址SA开始连续存放在存储器中,该数组掃行存放时,元素A[8, 5]起始地址为_____。
A.SA+141B. SA+144C. SA+222D. SA+225二、填空题*1.一维数组的逻辑结构是_______,存储结构是_______;对于二维或多维数组,分为按______和_______两种不同的存储方式。
线性结构顺序结构按行优先顺序按列优先顺序*2.已知广义表LS=((,x,y,z),(b,c)),运用head和tail函数取出原子c的运算是__________________________。
Head(tail(head(tail(LS))))1.数组A[1..10, -2..6, 2..8]以行优先顺序存储,设第一个元素的首址为100,每个元素占3个单元的存储空间,则元素A[5,0,7]的存储地址为_______。
9132.三维数据R[c1..d1,c2..d2, c3..d3]共含有______个元素。
(d1-c1+1)*(d2-c2+1)*(d3-c3+1)3.已知广义表L=(a,(b,c,d),c),运用head和tail函数取出原子b的运算是______________。
Head(head(tail(LS)))三、多项选择题1.广义表(a, b, c, d )的表头是______,表尾是______。
A. AB. (a, b )C. (d)D. (b, c, d)2. 广义表((a, b, c, d ))的表头是______,表尾是______。
第五章数组与广义表一、假设有二维数组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中。
数据结构第五章数组和广义表练习及答案一、选择题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.常对数组进行的两种基本操作是()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))的表头是(),表尾是()。
第五章数组和⼴义表习题_数据结构习题五数组和⼴义表⼀、单项选择题)1.常对数组进⾏的两种基本操作是( D.查找与索引C.B.索引与修改建⽴与删除A. 查找与修改K 个存储单元,⼆维数组中DataType A[m][n],2.对于 C 语⾔的⼆维数组每个数据元素占.( )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. ⾮零元素三元祖(i,j, aij)D. i,jC. aijB.数组A[0..5,0..6]的每个元素占五个字节,将其按列优先次序存储在起始地址为10004.( )的地址是A[5 ,5]的内存单元中,则元素。
A. 1175B. 1180C. 1205D. 1210A[N,N] 是对称矩阵,将下⾯三⾓(包括对⾓线)以⾏序存储到⼀维数组T[N (N+1)/2]5.对应T[k] 的下标k是(中,则对任⼀上三⾓元素)。
a[i][j](i-1)/2+j(j-i)/2+1((j-1)/2+i i-1 )/2+1D. jB. jA. iC. i j 沿⽤数组r 存储静态链表,结点的next 域指向后继,⼯作指针j 指向链中结点,使6.( )链移动的操作为。
A. j=r[j].nextB. j=j+1D. j=r[j]-> nextC. j=j->next对稀疏矩阵进⾏压缩存储⽬的是()。
7.A.便于进⾏矩阵运算.便于输⼊和输出B.节省存储空间C.降低运算的时间复杂度DLS=((a,b,c),(d,e,f)),函数取出LS 中原⼦运⽤head 和tail e 的运算是已知⼴义表8.。
)(A. head(tail(LS))B. tail(head(LS))C. head(tail(head(tail(LS)))D. head(tail(tail(head(LS))))⼴义表((a,b,c,d),表尾是())的表头是()。
第五章数组和广义表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.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分析:层序遍历的问题,一般都是借助队列来完成的,每次从队头取出一个元素的同时把它下一层的孩子插入队尾.这是层序遍历的基本思想.。
第五章数组和广义表
一,选择
1. 已知广义表L=((x,y,z),a,(u,t,w)),从L表中取出原子项t的运算是()。
A. head(tail(tail(L)))
B. tail(head(head(tail(L))))
C. head(tail(head(tail(L))))
D. head(tail(head(tail(tail(L)))))
2. 广义表A=(a,b,(c,d),(e,(f,g))),则下面式子的值为()。
Head(Tail(Head(Tail(Tail(A)))))
A. (g)
B. (d)
C. c
D. d
3.稀疏矩阵一般的压缩存储方法有两种,即()
A.二维数组和三维数组 B.三元组和散列
C.三元组和十字链表 D.散列和十字链表
4. 二维数组A的每个元素是由6个字符组成的串,其行下标i=0,1,…,8,列下标j=1,2,…,10。
若A按行先存储,元素A[8,5]的起始地址与当A按列先存储时的元素()的起始地址相同。
设每个字符占一个字节。
A. A[8,5]
B. A[3,10]
C. A[5,8]
D. A[0,9]
5. 对稀疏矩阵进行压缩存储目的是()。
A.便于进行矩阵运算 B.便于输入和输出
C.节省存储空间 D.降低运算的时间复杂度
6. 设A是n*n的对称矩阵,将A的对角线及对角线上方的元素以列为主的次序存放在一维数组B[1..n(n+1)/2]中,对上述任一元素a ij(1≤i,j≤n,且i≤j)在B中的位置为( )。
A. i(i-l)/2+j
B. j(j-l)/2+i
C. j(j-l)/2+i-1
D. i(i-l)/2+j-1
7. A[N,N]是对称矩阵,将下面三角(包括对角线)以行序存储到一维数组T[N(N+1)/2]中,则对任一上三角元素a[i][j]对应T[k]的下标k是()。
A. i(i-1)/2+j B. j(j-1)/2+i C. i(j-i)/2+1 D. j(i-1)/2+1
8. 设广义表L=((a,b,c)),则L的长度和深度分别为()。
A. 1和1
B. 1和3
C. 1和2
D. 2和3
9. 数组A[0..4,-1..-3,5..7]中含有元素的个数()。
A. 55 B.45 C. 36 D.16
10. 下面说法不正确的是( )。
A. 广义表的表头总是一个广义表
B. 广义表的表尾总是一个广义表
C. 广义表难以用顺序存储结构
D. 广义表可以是一个多层次的结构
一,选择
二,判断
1.一个稀疏矩阵A m*n采用三元组形式表示,若把三元组中有关行下标与列下标的值互换,并把m和n的值互换,则就完成了A m*n的转置运算。
()
2. 从逻辑结构上看,n维数组的每个元素均属于n个向量。
()
3. 稀疏矩阵压缩存储后,必会失去随机存取功能。
()
4. 对长度为无穷大的广义表,由于存储空间的限制,不能在计算机中实现。
()
5. 数组可看成线性结构的一种推广,因此与线性表一样可对它进行插入,删除操作。
()
6. 所谓取广义表的表尾就是返回广义表中最后一个元素。
()
7. 二维以上的数组其实是一种特殊的广义表。
()
8. 广义表的取表尾运算,其结果通常是个表,但有时也可是个单元素值。
()
9. 若一个广义表的表头为空表,则此广义表亦为空表。
()
10. 广义表中的元素或者是一个不可分割的原子,或者是一个非空的广义表。
()
四应用题
1. 画出下列广义表的两种存储结构图((),A,(B,(C,D)),(E,F))。
2. 设某表H如下:
其中A,B,C为子表名,a1,a2,b1,c1,c2,x为其元素。
试用广义表形式表示H,并写出运算HEAD(H)和TAIL(H) 函数从H中取出单元素a2的运算;(1)H(A(a1,a2),B(b1),C(c1,c2),x)
HEAD(TAIL(HEAD(H)))=a2
五,算法设计
1.设任意n个整数存放于数组A(1:n)中,试编写程序,将所有正数排在所有负数前面2. 设二维数组a[1..m, 1..n] 含有m*n 个整数。
判断a中所有元素是否互不相同?输出相关信息(yes/no)。
1.本题属于排序问题,只是排出正负,不排出大小。
可在数组首尾设两个指针i和j,i自小至大搜索到负数停止,j自大至小搜索到正数停止。
然后i和j所指数据交换,继续以上过程,直到 i=j为止。
void Arrange(int A[],int n)
//n个整数存于数组A中,本算法将数组中所有正数排在所有负数的前面 {int i=0,j=n-1,x; //用类C编写,数组下标从0开始
while(i<j)
{while(i<j && A[i]>0) i++;
while(i<j && A[j]<0) j--;
if(i<j) {x=A[i]; A[i++]=A[j]; A[j--]=x; }//交换A[i] 与A[j]
}
}//算法Arrange结束.
[算法讨论]对数组中元素各比较一次,比较次数为n。
最佳情况(已排好,正数在前,负数在后)不发生交换,最差情况(负数均在正数前面)发生n/2次交换。
用类c编写,数组界偶是0..n-1。
空间复杂度为O(1).
2.判断二维数组中元素是否互不相同,只有逐个比较,找到一对相等的元素,就可结论为不是互不相同。
如何达到每个元素同其它元素比较一次且只一次?在当前行,每个元素要同本行后面的元素比较一次(下面第一个循环控制变量p的for循环),然后同第i+1行及以后各行元素比较一次,这就是循环控制变量k和p的二层for循环。
int JudgEqual(ing a[m][n],int m,n)
//判断二维数组中所有元素是否互不相同,如是,返回1;否则,返回0。
{for(i=0;i<m;i++)
for(j=0;j<n-1;j++)
{ for(p=j+1;p<n;p++) //和同行其它元素比较
if(a[i][j]==a[i][p]) {printf(“no”); return(0); }
//只要有一个相同的,就结论不是互不相同
for(k=i+1;k<m;k++) //和第i+1行及以后元素比较
for(p=0;p<n;p++)
if(a[i][j]==a[k][p]) {printf(“no”); return(0); } }// for(j=0;j<n-1;j++)
printf(yes”); return(1); //元素互不相同
}//算法JudgEqual结束。