严蔚敏-数据结构课后习题及答案解析.doc

 第一章 绪论
一、选择题
1、组成数据得基本单位就是（ ）
（A）数据项（B）数据类型（C）数据元素（D）数据变量
2、数据结构就是研究数据得（ ）以及它们之间得相互关系。
（A）理想结构，物理结构 （B）理想结构，抽象结构
（C）物理结构，逻辑结构 （D）抽象结构，逻辑结构
3、在数据结构中，从逻辑上可以把数据结构分成（ ）
（A）动态结构与静态结构 （B）紧凑结构与非紧凑结构
（C）线性结构与非线性结构（D）内部结构与外部结构
4、数据结构就是一门研究非数值计算得程序设计问题中计算机得 （①）以及它们之间得（②）与运算等得学科。
① （A）数据元素（B）计算方法（C）逻辑存储（D）数据映像
② （A）结构 （B）关系 （C）运算 （D）算法
5、算法分析得目得就是（）。
（A） 找出数据结构得合理性 （B）研究算法中得输入与输出得关系
（C）分析算法得效率以求改进（D）分析算法得易懂性与文档性
6、计算机算法指得就是（①）,它必须具备输入、输出与（②）等5个特性。
① （A）计算方法（B）排序方法（C）解决问题得有限运算序列（D）调度方法
② （A）可执行性、可移植性与可扩充性（B）可行性、确定性与有穷性
（C）确定性、有穷性与稳定性 （D）易读性、稳定性与安全性
二、判断题
1、数据得机内表示称为数据得存储结构。（ ）
2、算法就就是程序。（ ）
3、数据元素就是数据得最小单位。（ ）
4、算法得五个特性为：有穷性、输入、输出、完成性与确定性。（ ）
5、算法得时间复杂度取决于问题得规模与待处理数据得初态。（ ）
三、填空题
1、数据逻辑结构包括________、________、_________ 与_________四种类型,其中树形结构与图形结构合称为_____。
2、在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点。
3、在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点得后续结点可以_________。
4、在图形结构中,每个结点得前驱结点数与后续结点数可以_________。
5、线性结构中元素之间存在________关系,树形结构中元素之间存在______关系,图形结构中元素之间存在_______关系。
6、算法得五个重要特性就是_______、_______、______、_______、_______。
7、数据结构得三要素就是指______、_______与________。
8、链式存储结构与顺序存储结构相比较,主要优点就是________________________________。
9、设有一批数据元素,为了最快得存储某元素,数据结构宜用_________结构,为了方便插入一个元素,数据结构宜用____________结构。
四、算法分析题
1、求下列算法段得语句频度及时间复杂度
参考答案：
一、选择题
1、 C 2、C 3、 C 4、 A、B 5、 C 6、C、B
二、判断题:
1、√ 2、 × 3、× 4、× 5、√
三、填空题
1、线性、树形、图形、集合? ；非线性（网状） 2、没有；1；没有；1 3、前驱；1；后继；任意多个 4、任意多个 5、一对一；一对多；多对多6、有穷性；确定性；可行性；输入；输出 7、数据元素；逻辑结构；存储结构 8、插入、删除、合并等操作较方便 9、顺序存储；链式存储
四、算法分析题
for(i=1; i<=n; i++)
for(j =1; j <=i ; j++)
x=x+1;
分析：该算法为一个二重循环，执行次数为内、外循环次数相乘，但内循环次数不固定，与外循环有关，因些，时间频度T(n)=1+2+3+…+n=n*(n+1)/2
有 1/4≤T(n)/n2≤1，故它得时间复杂度为Ｏ(n2), 即Ｔ(n)与n2 数量级相同。 2、分析下列算法段得时间频度及时间复杂度
for （i=1;i<=n;i++）
for (j=1;j<=i;j++)
for ( k=1;k<=j;k++)
x=i+j-k;
分析算法规律可知时间频度T(n)=1+(1+2)+(1+2+3)+、、、+(1+2+3+…+n)
由于有1/6 ≤ T（n）/ n3 ≤1，故时间复杂度为Ｏ(n3)
第二章 线性表
一、选择题
1、一个线性表第一个元素得存储地址就是100,每个元素得长度为2,则第5个元素得地址就是( )
（A）110 （B）108（C）100 （D）120
2、 向一个有127个元素得顺序表中插入一个新元素并保持原来顺序不变，平均要移动（ ）个元素。
（A）64（B）63 （C）63、5　　（D）7
3、线性表采用链式存储结构时，其地址（ ）。
(A) 必须就是连续得 (B) 部分地址必须就是连续得
(C) 一定就是不连续得 (D) 连续与否均可以
4、 在一个单链表中，若p所指结点不就是最后结点，在p之后插入s所指结点，则执行（ ）
（A）s->next=p;p->next=s; （B） s->next=p->next;p->next=s;
（C）s->next=p->next;p=s; （D）p->next=s;s->next=p;
5、在一个单链表中，若删除p所指结点得后续结点，则执行（ ）
（A）p->next=p>next->next; （B）p=p->next; p->next=p->next->next;
（C）p->next=p->next; （D）p =p->next->next;
6、下列有关线性表得叙述中，正确得就是（ ）
（A）线性表中得元素之间隔就是线性关系
（B）线性表中至少有一个元素
（C）线性表中任何一个元素有且仅有一个直接前趋
（D）线性表中任何一个元素有且仅有一个直接后继
7、线性表就是具有n个（ ）得有限序列（n≠0)
（A）表元素 （B）字符 （C）数据元素　 （D）数据项
二、判断题
1、线性表得链接存储，表中元素得逻辑顺序与物理顺序一定相同。（ ）
2、如果没有提供指针类型得语言，就无法构造链式结构。（ ）
3、线性结构得特点就是只有一个结点没有前驱，只有一个结点没有后继，其余得结点只有一个前驱与后继。（ ）
4、语句p=p->next完成了指针赋值并使p指针得到了p指针所指后继结点得数据域值。（ ）
5、要想删除p指针得后继结点，我们应该执行q=p->next ； p->next=q->next； free(q)。（ ）
三、填空题
1、已知P为单链表中得非首尾结点，在P结点后插入S结点得语句为：_______________________ 。
2、顺序表中逻辑上相邻得元素物理位置( )相邻 单链表中逻辑上相邻得元素物理位置_________相邻。
3、线性表L＝（a1，a2，、、、，an）采用顺序存储，假定在不同得n＋1个位置上插入得概率相同，则插入一个新元素平均需要移动得元素个数就是________________________
4、在非空双向循环链表中，在结点q得前面插入结点p得过程如下：
p->prior=q->prior;
q->prior->next=p;
p->next=q;
______________________;
5、已知L就是无表头结点得单链表，就是从下列提供得答案中选择合适得语句序列，分别实现：
（1）表尾插入s结点得语句序列就是_______________________________
(2) 表尾插入 s结点得语句序列就是_______________________________
1. p->next=s;
2. p=L;
3. L=s;
4. p->next=s->next;
5. s->next=p->next;
6. s->next=L;
7. s->next=null;
8. while(p->next!= Q)? p=p-next;
9. while(p->next!=null) p=p->next;
四、算法设计题
1、试编写一个求已知单链表得数据域得平均值得函数（数据域数据类型为整型）。
2、已知带有头结点得循环链表中头指针为head,试写出删除并释放数据域值为x得所有结点得c函数。
3、某百货公司仓库中有一批电视机，按其价格从低到高得次序构成一个循环链表，每个结点有价格、数量与链指针三个域。现出库（销售）m台价格为h得电视机，试编写算法修改原链表。
4、某百货公司仓库中有一批电视机，按其价格从低到高得次序构成一个循环链表，每个结点有价格、数量与链指针三个域。现新到m台价格为h得电视机，试编写算法修改原链表。
5、线性表中得元素值按递增有序排列，针对顺序表与循环链表两种不同得存储方式，分别编写C函数删除线性表中值介于a与b（a≤b）之间得元素。
6、设A=(a0,a1,a2,、、、,an-1),B=(b0,b1,b2,、、、,bm-1)就是两个给定得线性表,它们得结点个数分别就是n与m,且结点值均就是整数。
若n=m，且 ai= bi （0≤iB。
试编写一个比较A与B得C函数，该函数返回 -1或 0或 1，分别表示 AB。
7、试编写算法,删除双向循环链表中第k个结点。
8线性表由前后两部分性质不同得元素组成(a0,a1,、、、,an-1,b0,b1,、、、,bm-1),m与n为两部分元素得个数,若线性表分别采用数组与链表两种方式存储,编写算法将两部分元素换位成(b0,b1,、、、,bm-1,a0,a1,、、、,an-1),分析两种存储方式下算法得时间与空间复杂度。
9、用循环链表作线性表(a0,a1,、、、,an-1)与（b0,b1,、、、,bm-1）得存储结构,头指针分别为ah与bh，设计C函数，把两个线性表合并成形如（a0,b0,a1,b1,…）得线性表，要求不开辟新得动态空间,利用原来循环链表得结点完成合并操作,结构仍为循环链表,头指针为head,并分析算法得时间复杂度。
10、试写出将一个线性表分解为两个带有头结点得循环链表，并将两个循环链表得长度放在各自得头结点得数据域中得C函数。其中,线性表中序号为偶数得元素分解到第一个循环链表中,序号为奇数得元素分解到第二个循环链表中。
11、试写出把线性链表改为循环链表得C函数。
12、己知非空线性链表中x结点得直接前驱结点为y,试写出删除x结点得C函数。
参考答案：
一、选择题
1、 B 2、C 3、 D 4、 B 5、 A 6、A 7、C
二、判断题:
参考答案：1、×2、√3、×4、×5、√
三、填空题
1、s->next=p->next; p->next=s; 2、一定；不一定 3、n/2 4、q->prior=p; 5、(1)6) 3)
(2) 2) 9）1) 7)
四、算法设计题
1、
#include "stdio、h"
#include "malloc、h"
typedef struct node
{int data;
struct node *link;
}NODE;
int aver(NODE *head)
{int i=0,sum=0,ave; NODE *p;
p=head;
while(p!=NULL)
{p=p->link;++i;
sum=sum+p->data;}
ave=sum/i;
return (ave);}
2、
#include "stdio、h"
#include "malloc、h"
typedef struct node
{
int data; /* 假设数据域为整型 */
struct node *link;
}NODE;
void del_link(NODE *head,int x) /* 删除数据域为x得结点*/
{
NODE *p,*q,*s;
p=head;
q=head->link;
while(q!=head)
{if(q->data==x)
{p->link=q->link;
s=q;
q=q->link
free(s);}
else
{
p=q;
q=q->link;
}
}
}
3、
void del(NODE *head,float price,int num)
{
NODE *p,*q,*s;
p=head;q=head->next;
while(q->pricenext;
}
if(q->price==price)
q->num=q->num-num;
else
printf("无此产品");
if(q->num==0)
{
p->next=q->next;
free(q);
}
}
4、
#include "stdio、h"
#include "malloc、h"
typedef struct node
{
float price;
int num;
struct node *next;
}NODE;
void ins(NODE *head,float price,int num)
{
NODE *p,*q,*s;
p=head;q=head->next;
while(q->pricenext;
}
if(q->price==price)
q->num=q>num+num;
else
{
s=(NODE *)malloc(sizeof(NODE));
s->price=price;
s->num=num;
s->next=p->next;
p->next=s;
}
}
5、顺序表：
算法思想：从0开始扫描线性表，用k记录下元素值在a与b之间得元素个数，对于不满足该条件得元素，前移k个位置，最后修改线性表得长度。
void del（elemtype list[]，int *n，elemtype a，elemtype b）
{
int i=0，k=0；
while（i=alist[i]<=b) k++;
else
list[i-k]=list[i];
i++;
}
*n=*n-k; /* 修改线性表得长度*/
}
循环链表:
void del(NODE *head,elemtype a,elemtype b)
{
NODE *p,*q;
p= head;q=p->link; /* 假设循环链表带有头结点 */
while(q!=head && q->datalink;
}
while(q!=head && q->datalink;
free(r);

}
if(p!=q)
p->link=q;
}
6、
#define MAXSIZE 100
int listA[MAXSIZE],listB[MAXSIZE];
int n,m;
int compare(int a[],int b[])
{
int i=0;
while(a[i]==b[i]&&im&&i==m) return(1);
if(ielse if(a[i]>b[i]) return(1);
}
7、
void del(DUNODE　**head,int i)
{
DUNODE *p;
if(i==0)
{
*head=*head->next;
*head->prior=NULL;
return(0);
}　
Else
{for(j=0;jnext;
if(p==NULL||j>i) return(1);
p->prior->next=p->next;
p->next->prior=p->proir;
free(p);
return(0);
}
8、
顺序存储:
void convert(elemtype list[],int l,int h) /* 将数组中第l个到第h个元素逆置*/
{
int i;
elemtype temp;
for(i=h;i<=(l+h)/2;i++)
{
temp=list[i];
list[i]=list[l+h-i];
list[l+h-i]=temp;
}
}
void exchange(elemtype list[],int n,int m);
{
convert(list,0,n+m-1);
convert(list,0,m-1);
convert(list,m,n+m-1);
}
该算法得时间复杂度为O(n+m),空间复杂度为O(1)
链接存储:(不带头结点得单链表)
typedef struct node
{
elemtype data;
struct node *link;
}NODE;
void convert(NODE **head,int n,int m)
{
NODE *p,*q,*r;
int i;
p=*head;
q=*head;
for(i=0;ilink; /*q指向an-1结点 */
r=q->link;
q->link=NULL;
while(r->link!=NULL)
r=r->link; /*r指向最后一个bm-1结点 */
*head=q;
r->link=p;
}
该算法得时间复杂度为O(n+m),但比顺序存储节省时间(不需要移动元素,只需改变指针),空间复杂度为O(1)
9、
typedef struct node
{
elemtype data;
struct node *link;
}NODE;
NODE　*union(NODE　*ah,NODE *bh)
{
NODE　*a,*b,*head,*r,*q;
head=ah;
a=ah;
b=bh;
while(a->link!=ah&&b->link!=bh)
{
r=a->link;
q=b->link;
a->link=b;
b->link=r;
a=r;
b=q;
}
if(a->link==ah) /*a得结点个数小于等于b得结点个数 */
{
a->link=b;
while(b->link!=bh)
b=b->link;
b->link=head;
}
if(b->link==bh) /*b得结点个数小于a得结点个数 */
{
r=a->link;
a->link=b;
b->link=r;
}
return(head);
}
该算法得时间复杂度为O(n+m),其中n与m为两个循环链表得结点个数、
10、
typedef struct node
{
elemtype data;
struct node *link;
}NODE;
void analyze(NODE *a）
{
NODE　*rh，*qh，*r,*q,*p；
int i=0，j=0；/*i为序号就是奇数得结点个数 j为序号就是偶数得结点个数 */
p=a；
rh=（NODE *）malloc（sizeof（NODE））；/*rh为序号就是奇数得链表头指针 */
qh=(NODE *)malloc(sizeof(NODE)); /*qh为序号就是偶数得链表头指针 */
r=rh;
q=qh;
while(p!=NULL)
{
r->link=p;
r=p;
i++;
p=p->link;
if(p!=NULL)
{
q->link=p;
q=p;
j++;
p=p->link;
}
}
rh->data=i;
r->link=rh;
qh->data=j;
q->link=qh;
}
11、
typedef struct node
{
elemtype data;
struct node *link;
}NODE;
void change(NODE　*head)
{
NODE　*p;
p=head;
if(head!=NULL)
{
while(p->link!=NULL)
p=p->link;
p->link=head;
}
}
12、
typedef struct node
{
elemtype data;
struct node *link;
}NODE;
void del(NODE *x,NODE *y)
{
NODE *p,*q;
elemtype d1;
p=y;
q=x;
while(q->next!=NULL) /* 把后一个结点数据域前移到前一个结点*/
{
p->data=q->data;
q=q->link;
p=q;
p->link=NULL; /* 删除最后一个结点*/
free(q);
}
第三章 栈与队列
一、选择题
1、 一个栈得入栈序列就是a,b,c,d,e,则栈得不可能得输出序列就是（ ）。
（A） edcba（B）decba（C）dceab （D）abcde
2、栈结构通常采用得两种存储结构就是（ ）。
（A） 线性存储结构与链表存储结构（B）散列方式与索引方式
（C）链表存储结构与数组 （D）线性存储结构与非线性存储结构
3、判定一个栈ST(最多元素为m0)为空得条件就是（ ）。
（A） ST-〉top!=0 （B）ST-〉top0
（C）ST-〉top!=m0 （D）ST-〉top=m0
4、判定一个栈ST(最多元素为m0)为栈满得条件就是（ ）。
（A）ST->top!=0 （B）ST->top==0
（C）ST->top!=m0-1（D）ST->top==m0-1
5、一个队列得入列序列就是1,2,3,4,则队列得输出序列就是（ ）。
（A）4,3,2,1（B）1,2,3,4（C）1,4,3,2（D）3,2,4,1
6、循环队列用数组A[0,m-1]存放其元素值,已知其头尾指针分别就是front与rear则当前队列中得元素个数就是（ ）
（A）(rear-front+m)%m （B） rear-front+1 （C）rear-front-1（D）rear-front
7、栈与队列得共同点就是（ ）
（A） 都就是先进后出 （B）都就是先进先出
（C）只允许在端点处插入与删除元素（D）没有共同点
8、表达式a*(b+c)-d得后缀表达式就是（ ）。
（A）abcd*+-（B）abc+*d- （C）abc*+d-（D）-+*abcd
9、4个元素a1，a2，a3与a4依次通过一个栈，在a4进栈前，栈得状态，则不可能得出栈序就是（　　）
(A)a4，a3，a2，a1　(B)a3，a2，a4，a1
(C)a3，a1，a4，a2　(D)a3，a4，a2，a1
10、以数组Q[0、、m－1]存放循环队列中得元素，变量rear与qulen分别指示循环队列中队尾元素得实际位置与当前队列中元素得个数，队列第一个元素得实际位置就是（　　）
(A)rear－qulen　(B)rear－qulen＋m　
(C)m－qulen　　 (D)1＋（rear＋m－qulen）% m
二、填空题
1、栈得特点就是_______________________,队列得特点就是__________________________。
2、线性表、栈与队列都就是_____________________结构,可以在线性表得______________位置插入与删除元素，对于栈只能在________插入与删除元素，对于队列只能在_______插入元素与_________删除元素。
3、一个栈得输入序列就是12345,则栈有输出序列12345就是____________。(正确/错误)
4、设栈S与队列Q得初始状态皆为空，元素a1，a2，a3，a4，a5与a6依次通过一个栈，一个元素出栈后即进入队列Q，若6个元素出队列得顺序就是a3，a5，a4，a6，a2，a1则栈S至少应该容纳_____个元素。
三、算法设计题
1、假设有两个栈s1与s2共享一个数组stack[M],其中一个栈底设在stack[0]处，另一个栈底设在stack[M-1]处。试编写对任一栈作进栈与出栈运算得C函数push（x,i)与pop(i),i=l,2。其中i=1表示左边得栈，,i=2表示右边得栈。要求在整个数组元素都被占用时才产生溢出。

2、利用两个栈s1,s2模拟一个队列时,如何用栈得运算来实现该队列得运算?写出模拟队列得插入与删除得C函数。
一个栈s1用于插入元素,另一个栈s2用于删除元素、
参考答案：
一、选择题
1、 C 2、A 3、 B 4、 B 5、 B 6、B 7、C 8、C 9、C 10、D
二、填空题
1、先进先出；先进后出2、线性 ； 任何 ；栈顶；队尾；对头3、正确得 4、3

三、算法设计题
1、
#define M 100
elemtype stack[M];
int top1=0,top2=m-1;
int push(elemtype x,int i)
{
if(top1-top2==1) return(1); /*上溢处理*/
else
if(i==1) stack[top1++]=x;
if(i==2)stack[top2--]=x;
return(0);
}
int pop(elemtype *px,int i)
{
if(i==1)
if(top1==0) return(1);
else
{
top1--;
*px=stack[top1];
return(0);
}
else
if(i==2)
if(top2==M-1) return(1);
else
{
top2++;
*px=stack[top2];
return(0);
}
}
2、
elemtype s1[MAXSIZE],s2[MAZSIZE];
int top1,top2;
void enqueue(elemtype x)
{
if(top1==MAXSIZE) return(1);
else
{
push(s1,x);
return(0);
}}
void dequeue(elemtype *px)
{
elemtype x;
top2=0;
while(!empty(s1))
{
pop(s1,&x);
push(s2,x);
}
pop(s2,&x);
while(!empty(s2))
{
pop(s2,&x);
push(s1,x);
}
}
第四章 串
一、选择题
1、下列关于串得叙述中，正确得就是（ ）　
(A)一个串得字符个数即该串得长度 (B)一个串得长度至少就是1　　
(C)空串就是由一个空格字符组成得串 (D)两个串S1与S2若长度相同，则这两个串相等
2、字符串"abaaabab"得nextval值为(? )
(A)(0,1,01,1,0,4,1,0,1) (B)(0,1,0,0,0,0,2,1,0,1)
(C)(0,1,0,1,0,0,0，1,1) (D)(0,1,0,1,0,1,0,1,1)
3、字符串满足下式,其中head与tail得定义同广义表类似,如head(‘xyz’)= ‘x’,tail(‘xyz’)= ‘yz’,则s=( )。 concat(head(tail(s)),head(tail(tail(s))))= ‘dc’。
(A)abcd (B)acbd (C)acdb (D)adcb
4、串就是一种特殊得线性表,其特殊性表现在（ ）
(A)可以顺序存储 (B)数据元素就是一个字符
(C)可以链式存储 (D)数据元素可以就是多个字符
5．设串S1=‘ABCDEFG’,s2=‘PQRST’,函数CONCAT（X，Y）返回X与Y串得连接串，SUBSTR（S，I，J）返回串S从序号I开始得J个字符组成得字串，LENGTH（S）返回串S得长度，则CONCAT（SUBSTR（S1，2，LENGTH（S2）），SUBSTR（S1，LENGTH（S2），2））得结果串就是（ ）
（A）BCDEF (B) BCDEFG (C)BCPQRST (D)BCDEFEF
二、算法设计
1、分别在顺序存储与一般链接存储两种方式下,用C语言写出实现把串s1复制到串s2得串复制函数strcpy(s1,s2)。
2、在一般链接存储(一个结点存放一个字符)方式下,写出采用简单算法实现串得模式匹配得C语言函数int L_index(t,p)。
参考答案：
一、选择题
1、 A 2、B 3、 D 4、 D 5、 D
二、算法设计
1、
顺序存储：
#include "string、h"
#define MAXN 100
char s[MAXN];
int S_strlen(char s[])
{
int i;
for(i=0;s[i]!='\0';i++);
return(i);
}
void S_strcpy(char s1[],char s2[]) //4、3题
{
int i;
for(i=0;s1[i]!='\0';i++)
s2[i]=s1[i];
s2[i]='\0';
}
一般链接存储：
#include "stdio、h"
typedef struct node
{
char data;
struct node *link;
}NODE;
NODE *L_strcpy(NODE *s1)
{
NODE *s2,*t1,*t2,*s;
if(s1==NULL) return(NULL);
else
{
t1=s1;
t2=(NODE *)malloc(sizeof(NODE));
s2=t2;
while(t1!=NULL)
{
s=(NODE *)malloc(sizeof(NODE));
s->data=t1->data;
t2->link=s;
t2=s;
t1=t1->link;
}
t2->link=NULL;
s=s2;
s2=s2->link;
free(s);
return(s2);
}
}
2、
#include "stdio、h"
typedef struct node
{
char data;
struct node *link;
}NODE;
int L_index(NODE *t,NODE *p)
{
NODE *t1,*p1,*t2;
?int i;
t1=t;i=1;
while(t1!=NULL)
{
p1=p;
t2=t1->link;
while(p1->data==t1->data&&p1!=NULL)
{
p1=p1->link;
t1=t1->link;
}
if(p1==NULL) return(i);
i++;
t1=t2;
}
return(0);
}
第五章 数组与广义表
一、选择题
1、 常对数组进行得两种基本操作就是（ ）
（A）建立与删除（B）索引与修改（C）查找与修改（D）查找与索引
2、二维数组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]
3、数组A[8][10]中,每个元素A得长度为3个字节,从首地址SA开始连续存放在存储器内,存放该数组至少需要得单元数就是（ ）。
（A）80（B）100（C）240（D）270
4、数组A[8][10]中,每个元素A得长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按行存放时,元素A[7][4]得起始地址为（ ）。
（A）SA+141B）SA+144（C）SA+222（D）SA+225
5、数组A[8][10]中,每个元素A得长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按列存放时,元素A[4][7]得起始地址为（ ）。
（A）SA+141（B）SA+180（C）SA+222（D）SA+225
6、稀疏矩阵一般得压缩存储方法有两种,即（ ）。
（A） 二维数组与三维数组（B）三元组与散列
（C）三元组与十字链表 （D）散列与十字链表
7、若采用三元组压缩技术存储稀疏矩阵,只要把每个元素得行下标与列下标互换,就完成了对该矩阵得转置运算,这种观点（ ）。
（A）正确（B）错误
8、设矩阵A就是一个对称矩阵,为了节省存储,将其下三角部分按行序存放在一维数组B[1,n(n-1)/2]中,对下三角部分中任一元素ai,j(i<=j),在一组数组B得下标位置k得值就是（ ）。
（A）i(i-1)/2+j-1（B）i(i-1)/2+j（C）i(i+1)/2+j-1 (D)i(i+1)/2+j
二、填空题
1、己知二维数组A[m][n]采用行序为主方式存储,每个元素占k个存储单元,并且第一个元素得存储地址就是LOC(A[0][0]),则A[0][0]得地址就是_____________________。
2、二维数组A[10][20]采用列序为主方式存储,每个元素占一个存储单元,并且A[0][0]得存储地址就是200,则A[6][12]得地址就是________________。
3、有一个10阶对称矩阵A,采用压缩存储方式(以行序为主,且A[0][0]=1),则A[8][5]得地址就是__________________。
4、设n行n列得下三角矩阵A已压缩到一维数组S[1、、n*(n+1)/2]中,若按行序为主存储,则A[i][j]对应得S中得存储位置就是________________。
5、若A就是按列序为主序进行存储得4×6得二维数组,其每个元素占用3个存储单元,并且A[0][0]得存储地址为1000,元素A[1][3]得存储地址为___________,该数组