数据结构测试题答案0603.docx

数据结构测试题答案0603.docx

《数据结构测试题答案0603.docx》由会员分享，可在线阅读，更多相关《数据结构测试题答案0603.docx（22页珍藏版）》请在冰豆网上搜索。

数据结构测试题答案0603

第1章绪论答案

一、填空题

1、操作对象，关系，操作

2、数据对象，关系

3、线性结构，非线性结构，集合，线性结构，树型结构，图型结构

4、一对一，一对多，多对多

5、无，1，无，1

6、前驱，1,

7、任意

8、逻辑结构，物理结构，运算

9、顺序结构，链式结构，索引结构，散列结构

10、插入，删除，修改，查找，排序

11、时间，空间

二、单项选择题

CCACB

三、判断

1-4：

×√××5-8：

√√×√

四、

（1）、n3

（2）、n（n+1）（n+2）/6

（3）、n（n+1）/2

（4）、n

（5）、int（sqrt（n））（向下取整）

（6）、1100

五、

1、O（m*n）2、O（n2）3、O（n2）4、log3n

六、略

第二章线性表答案

一、填空

1、表长的一半，插入、删除位置

2、n-i+1

3、n-i

4、O

（1），直接访问

5、必定，不一定

6、头指针，头结点的指针域，其前驱结点的指针域

7、前驱结点，O（n）

8、p->next==La

9、a）s->next=p->next;p->next=s;

b）q=L;while（q->next!

=p）q=q->next;q->next=s;s->next=p;

c）s->next=L;L=s;

d）q=p;while（q->next!

=NULL）q=q->next;s->next=q->next;q->next=s;

二、判断正误

1-5:

×××××6-10:

×××××

三、单项选择题

CAAACDBCBD

四、简答题

1、①顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。

优点：

存储密度大（＝1），存储空间利用率高。

缺点：

插入或删除元素时不方便。

②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

优点：

插入或删除元素时很方便，使用灵活。

缺点：

存储密度小（<1），存储空间利用率低。

顺序表适宜于做查找这样的静态操作；链表宜于做插入、删除这样的动态操作。

若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；

若线性表的长度变化较大，且其主要操作是插入、删除操作，则采用链表。

2、单链表中不可以，因为无法找到其前驱结点；单循环链表可以，时间复杂度为O（n）

五、阅读分析题

StatusDeleteK（SqList&a,inti,intk）{

//本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素

if（i<1||k<0||i+k>a.length）returnINFEASIBLE;//参数不合法

else{

for（count=1;count

//删除一个元素

for（j=a.length;j>=i+1;j--）a.elem[j-1]=a.elem[j];

a.length--;

}

returnOK;

}//DeleteK

注：

花双线的地方为错误的地方

改后：

StatusDeleteK（SqList&a,inti,intk）{

//本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素

if（i<1||k<0||i+k>a.length+1）returnINFEASIBLE;//参数不合法

else{

for（j=i+k;j<=a.length;j++）a.elem[j-k]=a.elem[j];

a.length-=k;

}

returnOK;

}//DeleteK

六、编程题

1、s->next=p->next;p->next=s;

2、

（1）voidReverse_Sq（SqList&L）{

for（i=0;j=L.length-1;i

L.elem[i]<->L.elem[j];

}

（2）voidReverse_LinkList（LinkList&L）{

p=L->next;//p指向首元结点

L->next=NULL:

//头结点的next置为空，即和后面的结点断开，分成2个单链表，一个是只有头结点的空链表，一个是含有n个数据结点的链表

while（p）//当p不空时，即还有未处理的结点

{//将数据结点依次插入头结点之后，即采用头插法

q=p->next;//q指示p的后继结点

p->next=L->next;//p所指结点插入头结点之后

L->next=p;//头结点的next指向*p结点

p=q;//p指向下一结点

}

}

3、

voidDelete_X（LinkList&head）

{

p=head;

q=head->next;

while（q!

=head）

{

if（q->data==x）

{

p->next=q->next;

q=p->next;

}

else{

p=q;q=q->next;

}

}

}

4、

voiddevide（LinkList&L,LinkList&La,LinkList&Lb,LinkList&Lc）

{

La=L;//La利用原表头结点

Lb=（LinkList）malloc（sizeof（LNode））;

Lc=（LinkList）malloc（sizeof（LNode））;

p=L->next;

La->next=Lb->next=Lc->next=NULL;

pa=La；

pb=Lb；

pc=Lc；

while（p）

{q=p->next;

if（p->data>=’a’&&p->data<=’z’||p->data>=’A’&&p->data<=’Z’）

pa->next=p;//字母插入La表中

elseif（p->data>=’0’&&p->data<=’9’）

pb->next=p;//数字插入Lb中

elsepc->next=p;//其他插入Lc中

p=q;

}

pa->next=La;//形成循环链表

pb->next=Lb;

pc->next=Lc;

}

第三章栈和队列

一、选择题

1-5：

DCCBD6-10：

AB

二、简答题

1、略（见课件）

2、略

3、思路：

考虑栈里元素最多的时候有几个元素，栈的容量就是几。

答案：

3（栈里元素最多的时候是s1,s5,s6）

4、

（1）将栈中的数据逆置

（2）删除栈s中所有值为e的元素

（3）将队列Q中的元素逆置

三、算法题

见第3章课后习题答案

第四章串

一、选择题

BBB

二、简答题

1、14；

“I□AM□A□”

“□”

6

“I□AM□A□WORKER”

“I□AM□A□GOOD□WORKER”（□表示空格）

2、略

第五章数组和广义表

一、选择题

CBBD

二、填空题

1、线性结构，顺序存储结构，行优先存储，列优先存储，（i*n+j）*L（L为每个元素的字节数）

2、326（=200+12*10+6）*1

3、k=i（i+1）/2+j+1（注意数组S从1号单元开始存储）

三、简答题

1、

（1）B[]容量应为55；

（2）行序存储上三角（i<=j，行列下标从0开始），第i行存储的元素个数为n-i，这些元素从A[i][i]-A[i][n-1]，因此，A[8][5]（下三角中的元素）的地址应转换为求A[5][8]的地址。

k=（n+（n-1）+…+（n-i+1））+j+1-i-1=i（2n-i+1）/2+j-i=i（2n-i-1）+ji<=j时

所以：

k=5*（2*10-5-1）/2+8=43

2、矩阵元素从A[0][0]，即行列下标从0开始。

k=3*i-1+j-i+1-1=2i+j-1

3、第1种结构：

第2种结构：

4、

（1）GETHEAD【（（a，B，（c，D）））】=（a，B，（c，D））

（2）GETTAIL【（（a，B，（c，D）））】=（）

（3）GETTAIL【GETHEAD【（（a，B，（c，D）））】】=（B，（c，D））

（4）GETHEAD【GETTAIL【GETHEAD【（（a，B，（c，D）））】】】=B

5、（），（（）），2，2

四、

voidmove（ElemTypeC[]，intn）

{

i=0;

j=n-1;

while（i

{

while（C[i]%2!

=0）i++;//从前向后找到1个偶数

while（C[j]%2==0）j--;//从后向前找到1个奇数

c[i]<->C[j];//将前面找到的偶数和后面找到的奇数交换，即将奇数前移，偶数后移

i++；

j--；

}

}

注：

本算法虽然是两层循环，但i、j指针从两端向中间移动，相遇时停止，只对数组扫描了一遍，因此时间复杂度为O（n）

第六章树与森林

一、选择题

1-5：

DBCAC6-10：

BBBAB（同2）11-12：

AA

二、填空题

1、n+1

2、1，50（即最后一个叶子的双亲，101/2）

3、k，2k-1

4、33

5、32

三、判断题

1-5：

×√××√6-10：

√××√×11：

×

四、简答题

1、高度最小的树高度为2，有n-1个叶子结点，1个分支结点；高度最大的树的高度为n，有1个叶子结点，n-1个分支结点。

2、

3、

（1）任意结点均无左孩子的二叉树

（2）任意结点均无右孩子的二叉树

（3）只有根结点的二叉树

4、用指针q指向要求的后继结点。

if（p->Rtag==1）q=p->Rc;

elseif（p->Ltag==0）q=p->Lc;

elseq=p->Rc;

5、用指针q指向要求的后继结点。

if（p->Rtag==1）q=p->Rc;

else{

q=p->Rc；//右子树的根

while（q->Ltag==0）q=q->Lc;

}//最左下的结点

四、构造题

1、二叉树为：

后序遍历序列为：

EDCBIHJGFA

2、参考答案（不唯一，但两个组合的数值是固定的，左右可颠倒）：

编码：

c1：

0100c2:

10c3:

0000c4:

0101c5:

001c6:

011c7:

11c8:

0001

WPL=2*（25+36）+3*（10+11）+4*（3+4+5+6）=257

3、

五、算法设计题

1、intleaves（BiTreet）

{

if（t==NULL）return0;

elseif（t->lchild==NULL&&t->rchild==NULL）return1;

elsereturnleaves（t->lchild）+leaves（t->rchild）;

}

2、

voidexchange（BiTree&t）

{

if（t==NULL||t->lchild==NULL&&t->rchild==NULL）return;

else{

exchange（t->lchild）;

exchange（t->rchild）;

t->lchild<—>t->rchild;

}

}

3、

statuszhengze（BiTreet）

{

if（t==NULL||t->lchild==NULL&&t->rchild==NULL）returnTRUE;

elseif（t->lchild&&!

t->rchild||!

t->lchild&&t->rchild）returnFALSE;

elsereturnzhengze（t->lchild）&&zhengze（t->rchild）;

}

4、

intnode（BiTreet）

{

if（t==NULL||t->lchild==NULL&&t->rchild==NULL）return0;//空树或只有1个根结点的二叉树中，度为1的结点有0个

elseif（t->lchild&&!

t->rchild||!

t->lchild&&t->rchild）//根结点只有左子树或只有右子树

return1+node（t->lchild）+node（t->rchild）;//根结点度为1，加上左右子树中度为1的结点数

elsereturnnode（t->lchild）+node（t->rchild）;//根结点度不为1，返回左右子树中度为1的结点数

}

第七章图

一、选择题

1-5：

CBCCD6-10：

（AC）AA（BC）B

二、填空题

1、1

2、先i后j

三、判断题

1-5：

√×√√√6-7：

××

四、解答题

1、有1000*1000=1000000个矩阵元素，有1000个非零元素

2、邻接矩阵中第i列元素之和；将邻接矩阵中第i行元素清0。

3、

（从顶点1出发的深度优先生成树）（从顶点2出发的广度优先生成树）

4、

顶点

i=1

i=2

i=3

i=4

i=5

i=6

2

15

（1,2）

15

（1,2）

15

（1,2）

15

（1,2）

15

（1,2）

15

（1,2）

3

2

（1,3）

4

12

（1,4）

12

（1,4）

11

（1,3,6,4）

11

（1,3,6,4）

5

∞

10

（1,3,5）

10

（1,3,5）

6

∞

6

（1,3,6）

7

∞

∞

16

（1,3,6,7）

16

（1,3,6,7）

14

（1,3,6,4,7）

vj

3

6

5

4

7

2

S={1}

S={1，3}

S={1，3，6}

S={1，3，6，5}

S={1，3，6，5，4}

S={1，3，6，5，4，7}

S={1，3，6，5，4，7，2}

标红色的为到各顶点的最短路径的长度和路径。

5、

（1）

顶点

1

2

3

4

5

6

入度

3

2

1

1

2

2

出度

0

2

2

3

1

3

（2）邻接矩阵

（3）邻接表

0

1

^

1

2

2

3

3

4

4

5

5

6

（4）逆邻接表

0

1

1

2

2

3

3

4

4

5

5

6

（5）强连通分量

6、略

7、略。

请参考题4

8、略

五、算法设计题

1、见邮箱里的实验程序

2、见邮箱里的实验程序

3、见邮箱里的实验程序

补充：

将习题集中关于最小生成树的题目做一下。

第九章查找

一、选择题

1-5：

（CACB）DCDD6-10：

CCDBB11-12：

DB

二、填空题

1、97

2、索引表，块

3、16

4、1，2，4，8，5，3.7

5、哈希查找

6、O（n），O（log2（n+1）），O（

）

7、4，4，8，3

8、hash（K），m-1，i，K

9、中序

三、简答题

1、当待查找的关键字无序排列时，查找性能较好；当待查找的关键字序列有序时性能最差。

2、折半查找的判定树：

ASL=（1*1+2*2+3*4+4*3）/10=2.9

3、

下标

0

1

2

3

4

5

6

7

8

9

10

元素

22

41

30

01

53

46

13

67

查找次数

1

1

2

2

1

1

2

6

H（22）=（3*22）%11=0

H（41）=（3*41）%11=2

H（53）=（3*53）%11=5

H（46）=（3*46）%11=6

H（30）=（3*30）%11=2，冲突；H1（30）=3

H（13）=（3*13）%11=6，冲突；H1（13）=7

H（01）=（3*1）%11=3，冲突；H1（01）=4

H（67）=（3*67）%11=3，冲突；H1（67）=4，冲突；H2（67）=5，冲突；H3（67）=6，冲突；H4（67）=7，冲突；H5（67）=8

ASL成功=（1*4+2*3+6）/8=2

ASL不成功=（1+0+7+6+5+4+3+2+1+0+0）/11=29/11=2.64

4、

（1）二叉排序树

ASL=（1*1+2*2+3*3+3*4+2*5+6）/12=4.25

（2）折半查找的判定树请自己画，请参考题2。

ASL=（1*1+2*2+3*4+4*5）/12=37/12

（3*）平衡的二叉排序树（步骤略，上课已讲）

ASL=（1+2*2+3*4+4*4+5*1）/12=19/6

5、线性探测处理冲突略，请参考题3

链地址法处理冲突：

ASL=（5*1+2*2+2*3）/9=5/3

6、A——

（2）B——

（1）C——（4）D——（3）

四、算法设计题

1、略

2、

statusjudge（BiTreet）

{

if（!

t||!

t->lchild&&!

t->rchild）returnTRUE;//空树或只有根结点，是二叉排序树

elseif（t->lchild&&t->lchild->data>t->data||t->rchild&&t->rchild->datadata）

//左孩子值大于根结点的值或右孩子值小于根结点的值，不是二叉排序树

returnFALSE;

elseif（!

t->rchild&&t->lchild->datadata）

//只有左子树且左孩子值小于根结点的值

returnjudge（t->lchild）;//若左子树是二叉排序树则整棵树是，否则不是

elseif（!

t->lchild&&t->rchild->data>t->data）

//只有右子树且左孩子值大于根结点的值

returnjudge（t->rchild）;//若右子树是二叉排序树则整棵树是，否则不是

elseif（t->lchild&&t->rchild）//左右子树都有

returnjudge（t->lchild）&&judge（t->rchild）;//左右子树都是二叉排序树则整棵树是，//否则不是

}

3、

intlevel（BiTreet,BiNode*p）

{

if（!

t）return0;

h=1;

q=t;

while（q）{

if（p->data==t->data）returnh;

elseif（p->datadata）

{q=q->lchild;h++;}//小于根的值，向左子树上继续查找，结点层次加1

else{q=q->rchild;h++;}//大于根的值，向右子树上继续查找，结点层次加1

}

returnh;

}

4、

voidInsert（SqList&L,ElemTypex）

{

low=0;

high=L.length-1;

while（low<=high）

{

mid=（low+high）/2;

if（x

elselow=mid+1;

}

for（j=L.length-1;j>high;j--）

L.elem[j+1]=L.elem[j];

L.elem[high+1]=x;

}

第十章排序

一、选择题

1-5：

CBBDD6-10：

ABBCB11-14：

ADCD

二、填空题

1、大顶堆

2、有，无

3、③，①，②，④，②，④，⑦

4、有序的

5、high，low，low，high（课本上有算法）

6、堆排序

7、希尔排序，选择排序，快速排序，堆排序

8、快速排序

9、堆排序，快速排序

10、n-1

三、判断题

1-5：

×√×√√6-10：

√××√×

四、简答题

1、略

2、最坏情况是关键字的初始序列已经有序时，此时，可以在第一个元素、最后一个元素、中间元素中选择值居中的元素作为枢轴，将其与第一个元素交换位置即可

3、

（1）087，503，512，061，908，170，897，275，653，426

（2）170,087，275，061，426，503，897，512，653，908

（3）426，087，275，061，170，503，897，908，653，512

（4）087，653，897，503，426，170，512，275，061，908

（5）087，503，061，512，170，908，275，897，426，653

（6）170，061，512，503，653，275，426，087，897，908

4、4，1，3，2，6，5，7

5、A——（3）B——

（2）C——（5）D——

（1）E——（4）

五、算法设计题

1、见课本

2、参考测试题第五章的算法题