数据结构章节练习题答案.docx

数据结构章节练习题答案.docx

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

数据结构章节练习题答案

数据结构期末复习练习题答案

（仅供参考）

第一章绪论

一、单选题

1.A2.C3.B4.C5.D6.B

二、填空题

1.集合结构、线性结构、树型结构、图形结构2.顺序、链式3.1:

1、1:

N、M:

N

4.数据定义、操作声明5.引用形参（或指针形参）6.引用类型（或指针类型）7.实参、值

8.stdio.h、file.h9.stdlib.h、rand（）%2110.sizeof（a）、a+i*sizeof（a[0]）、a+i

11.参数类型、数量、次序12.2、用户自定义13.==、ra、rb14.O（n）、O（m*n）

15.n、n（n+1）/2、O（n2）16.O（n）

第二章线性表

一、单选题

1.B2.A3.C4.B5.D6.C

二、填空题

1.元素值、指针2.（38,56,25,60,42,74）3.O（n）、O

（1）4.

（1）、O（n）5.i-1、i+1

p->next、a[p].next7.表头8.前驱、后继9.表尾、表头

10．HL->next==NULL、HL->next==HL

三、应用题

1.

（1）（79,62,34,57,26,48）

（2）（26,34,48,57,62,79）

（3）（26,34,39,48,57,62）

2．12，26，9，8，15，30，50）

3．

（1）ElemTypeDMValue（List&L）{

if（ListEmpty（L））{//空线性表

cerr<<"ListisEmpty!

"<

exit

（1）;

}

ElemTypex;//x存放最小元素

x=L.list[0];

intk=0;//k存放最小元素的下标

for（inti=1;i

if（L.list[i]

L.list[k]=L.list[L.size-1];//最后一个元素填补最小元素位置

L.size--;//线性表长度减1

returnx;//返回最小元素

}

2）ElemTypeDelete（List&L,inti）{

if（i<1||i>L.size）{//判断i的合法性

printf（"Indexisoutrange!

\n”）;

exit

（1）;

}

ElemTypex=L.list[i-1];//保存被删除元素

for（intj=i-1;j

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

L.size--;//长度减1

returnx;//返回被删元素

}

（3）voidInsert（List&L,inti,ElemTypex）{

if（i<1||i>L.size+1）{//判断i的合法性

printf（"Indexisoutrange!

\n"）;

exit

（1）;

}

if（L.size==MaxSize）{//判断线性表满

printf（"Listoverflow!

\n"）;

exit

（1）;

}

for（intj=L.size-1;j>=i-1;j--）//元素后移，产生插入位置

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

L.list[i-1]=x;//元素插入

L.size++;//长度加1

}

（4）voidDelete（List&L,ElemTypex）{

inti=0;

while（i

if（L.list[i]==x）{//删除x元素

for（intj=i+1;j

L.list[j-1]=L.list[j];

L.size--;

}

elsei++;//寻找下一个x元素的位置

}

4．

（1）voidDelete（LNode*&HL,inti）{

if（i<1||HL==NULL）{//判断i的合法性或空链表

cerr<<"indexisoutrange!

"<

exit

（1）;

}

LNode*ap,*cp;

ap=NULL;cp=HL;//cp指向当前结点，ap指向其前驱结点

intj=1;

while（cp!

=NULL）//查找第i个结点

if（j==i）//找到第i个结点

break;//cp指向的结点即为第i个结点

else{//继续向后寻找

ap=cp;

cp=cp->next;

j++;

}

if（cp==NULL）{//没有找到第i个结点

cerr<<"Indexisoutrange!

"<

exit

（1）;

}

if（ap==NULL）//删除第1个结点（即i=1）

HL=HL->nextl

else

ap->next=cp->next;//删除第i个结点

deletecp;//释放被删除结点的空间

}

（2）voidInsert（LNode*&HL,constElemType&x）{

LNode*newptr=newLNode;//申请一个新结点

if（newptr==NULL）{//分配失败

cerr<<"Memoryallocationfailare!

"<

exit

（1）;

}

newptr->data=x;

if（HL==NULL||xdata）{//空表或x小于表头结点，

newptr->next=HL;//作为新表头结点插入

HL=newptr;

return;

}

//查找插入位置

LNode*cp=HL->next;//用cp指向当前结点（即待查结点）

LNode*ap=HL;//用ap作为指向当前结点的前驱结点指针

while（cp!

=NULL）

if（xdata）break;//找到插入位置

else{ap=cp;cp=cp->next;}//继续查找插入位置

newptr->next=cp;ap->next=newptr;//插入新结点

}

（3）ElemTypeMaxValue（LNode*HL）{

if（HL==NULL）{//空表

cerr<<"Linkedlistisempty!

"<

exit

（1）;

}

ElemTypemax=HL->data;

LNode*p=HL->next;

while（p!

=NULL）{//寻找最大值

if（maxdata）max=p->data;

p=p->next;

}

returnmax;

}

（4）intCount（LNode*HL,ElemTypex）{

intn=0;

LNode*p=HL;

while（p!

=NULL）{

if（p->data==x）n++;

p=p->next;

}

returnn;

}

第三章稀疏矩阵和广义表

一、单选题

1.A2.B

二、填空题

1.行号、列号、元素值2.行号、列号3.引用（或指针）4.等于5.4、56.列号、行号7.单、表8.括号9.310.元素值、子表指针11.true、NULL

三、应用题

1．

（1）（（1,2,4）,（2,4,-3）,（2,7,1）,（3,1,8）,（4,4,5）,（5,2,-7）,（5,6,2）,（6,4,6））

12234556

24714264

4-3185-726

（2）

（3）（（1,3,8）,（2,1,4）,（2,5,-7）,（4,2,-3）,（4,4,5）,（4,6,6）,（6,5,2）,（7,2,1））

12244467

31524652

84-7-35621

2．

（1）A：

长度：

1深度：

2

（2）B：

长度：

3深度：

1（3）C：

长度：

2深度：

3

（4）D：

长度：

2深度：

2（5）E：

长度：

3深度：

3（6）F：

长度：

1深度：

4

第四章栈和队列

一、单选题

1.A2.B3.C4.A5.B6.B7.D8.D

二、填空题

1.队尾、队首2.后进先出（LIFO）、先进先出（FIFO）3.栈顶指针、存储4.栈顶元素、栈顶指针

5.front==rear、（rear+1）%QueueMaxSize==front6.-1、StackMaxSize-1

7.栈空、空队、队列只有一个元素8.新结点的指针域、栈顶指针9.指针域、栈顶指针

10.队尾指针、存储11.top==012.p->next=HS、HS=p13.HS=HS->next

14.（front==rear）&&（front<>NULL）15.3425615+-/8*+

16.（24+8）*3/（4*（10-7））、8

三、应用题

121553018

四、编程题

递归算法：

longFib（intn）{

if（n==1||n=2）//终止递归条件

return1;

else

returnFib（n-1）+Fib（n-2）;

}

非递归算法：

longFib（intn）{

inta,b,c;//c代表当前项，a和b分别代表当前项前面的第2项和第1项

a=b=1;

if（n==1||n==2）

return1;

else

for（inti=3;i<=n;i++）{

c=a+b;//求当前项

a=b;//产生第2项

b=c;//产生第1项

}

returnc;//返回所求的第n项

}

递归算法的时间复杂度为O（2n），空间复杂度为O（n）；非递归算法的时间复杂度为O（n），空间复杂度为O

（1）。

第五章树和二叉树

一、填空题

1.n-12.5、503.64.31、215.10、4、36.2、1、1、67.B、I和J8.69.2i、2i+1、?

i/2?

10.1611.5、1812.a、f、空结点（即无右孩子结点）13.4、2、3

14.a[2*i]、a[2*i+1]、a[i/2]15.2i-1、2j+116.A[2*i+1]、a[2*i+2]、a[i/2]

17.2n、n-1、n+118.10、519.abcdef、cbaedf、cbefda、abdcef20.abecfhijgd、abcdefghij

二、应用题

1．voidRequest（intA[],intn,inti）{

if（i>n）{

cerr<<"编号为"<

"<

exit

（1）;

}

cout<<"当前结点为"<

intj=i/2;//下标为j的结点是下标为i结点的双亲

if（j>0）

cout<<"双亲：

"<

else

cout<<"树根没有双亲结点！

"<

if（2*i

cout<<"左孩子：

"<

cout<<"右孩子：

"<

}

elseif（2*i==n）{

cout<<"左孩子：

"<

cout<<"无右孩子！

"<

}

else

cout<<"无孩子！

"<

}

2．voidCount（BTreeNode*BT,int&C1,int&C2）{

if（BT!

=NULL）{

C1++;//统计所有结点数

if（BT->left==NULL&&BT->right==NULL）

C2++;//统计叶子结点数

Count（BT->left,C1,C2）;

Count（BT->right,C1,C2）;

}

}

3．

（1）abecfgkdhilmj

（2）abcdefghijklm

（3）

第六章二叉树的应用

一、单选题

1.C2.B3.D4.C5.A6.D

二、填空题

1.小于、大于等于

2.按升序排列的有序序列

3.找到、左子树、右子树

4.2i+1、2i+2

5.最小值、最大值

6.堆尾、堆顶、向下

三、应用题

1.

2.初态：

空堆（）

插入38后：

（38）

插入64后：

（38,64）

插入52后：

（38,64,52）

插入15后：

（15,38,52,64）

插入73后：

（15,38,52,64,73）

插入40后：

（15,38,40,64,73,52）

插入48后：

（15,38,40,64,73,52,48）

插入55后：

（15,38,40,55,73,52,48,64）

插入26后：

（15,26,40,38,73,52,48,64,55）

插入12后：

（12,15,40,38,26,52,48,64,55,73）

3.初态堆：

（12,15,40,38,26,52,48,64）

删除第1个元素后堆：

（15,26,40,38,64,52,48）

删除第2个元素后堆：

（26,38,40,48,64,52）

删除第3个元素后堆：

（38,48,40,52,64）

删除第4个元素后堆：

（40,48,64,52）

4.哈夫曼树：

WPL=3*4+7*3+8*3+2*4+6*3+10*2+14*2=131

四、算法设计

1．boolFind（BTreeNode*BST,ElemType&item）

{

while（BST!

=NULL）

{

if（item==BT->data）{//找到

item=BST->data;

returntrue;

}

elseif（itemdata）BST=BST->left;//转左子树查找

elseBST=BST->right;//转右子树查找

}

returnfalse;//没有找到

}

2．（i-1）/2

HBT.heap[i]=HBT.heap[j]

i=j

第七章图

一、填空题

1.22、n（n-1）/2、n（n-1）3、n-14、邻接矩阵、邻接表、边集数组5、n*n（或n行n列）6、e、2e7、出边、入边8、e、e9、O（n）、O（e/n）、O（e）10、O（n2）、O（n）+O（e）、O（e）+O（n）

11、O（n2）、O（e）12、014253、01234513、ABCDE、ABCED14、22

15、（0,1）5，（1,3）3，（3,2）6，（1,4）816、（1,3）3，（0,1）5，（3,2）6，（1,4）8

17、链栈

18、n、n-1

二、应用题

1．

（1）采用邻接矩阵表示得到的顶点序列如下表所示：

图深度优先序列广度优先序列

G401283456790142738659

G5012584736013426758

（2）采用邻接表表示得到的顶点序列如下表所示：

图深度优先序列广度优先序列

G404389567120413728695

G5047583612043175628

2．唯一的一种拓扑序列为：

1402357689

第八章查找

一、填空题

1、（n+1）/2、O（n）2、见p264公式ASL=…、O（log2n）3、37/124、顺序、有序5、1、3

6.二叉搜索树、理想平衡树7.6、31、198、索引、开始地址9、（12,63,36）、（55,40,82）、（23,74）

10、3、3、211、哈希12、链接13、2、7/514、515、开放定址、链接16、3、2

二、应用题

1．

（1）顺序查找：

ASL=（1+2+3+…+25）/25=13

（2）二分查找：

ASL=（1+2*2+4*3+8*4+10*5）/25=99/25=3.96

（参见上图的二分查找树）

2．哈希函数：

H（K）=k%m其中依题意得m=13

H（32）=32%13=6

H（75）=75%13=10

H（29）=29%13=3

H（63）=63%13=11

H（48）=48%13=9

H（94）=94%13=3（冲突）

设d0=H（K）=H（94）=3

d1=（d0+1）%m=（3+1）%13=4

H（25）=25%13=12

H（46）=46%13=7

H（18）=18%13=5

H（70）=70%13=5（冲突）

设d0=H（K）=H（70）=5

d1=（d0+1）%m=（5+1）%13=6（冲突）

d2=（d1+1）%m=（6+1）%13=7（冲突）

d3=（d2+1）%m=（7+1）%13=8

ASL=（8*1+1*2+1*4）/10=1.4

3．哈希函数：

H（K）=k%m其中依题意得m=11

H（32）=32%11=10

H（75）=75%11=9

H（29）=29%11=7

H（63）=63%11=8

H（48）=48%11=4

H（94）=94%11=6

H（25）=25%11=3

H（46）=46%11=2

H（18）=18%11=7

H（70）=70%11=4

ASL=（8*1+2*2）/10=1.2

三、算法设计

递归算法：

intBinsch（ElemTypeA[],intlow,inthigh,KeyTypeK）{

if（low<=hight）{

intmid=（low+high）/2;

if（K==A[mid].key）

returnmid;//查找成功，返回元素的下标

elseif（K

returnBinsch（A,low,mid-1,K）;//在左子表上继续查找

else

returnBinsch（A,mid+1,high,K）;//在右子表上继续查找

}

else

return-1;//查找失败，返回-1

}

非递归算法：

intBinsch（ElemTypeA[],intn,KeyTypeK）{

intlow=0,high=n-1;

while（low<=hight）{

intmid=（low+high）/2;

if（K==A[mid].key）

returnmid;//查找成功，返回元素的下标

elseif（K

high=mid-1;//在左子表上继续查找

else

low=mid+1;//在右子表上继续查找

}

return-1;//查找失败，返回-1

}

第九章排序

一、填空题

1、插入、堆2、快速、归并3、O（n2）、O（n）4、?

n/2?

-1、n-15、O（log2n）、O（nlog2n）

6、8479563040467、O（nlog2n）、O（n2）8、O（log2n）、O（n）9、两端、中间

10、38404656798011、4412、élog2nù或élog2nù+1

13、O（n）、O（nlog2n）、O（n）14、6、4、815、384656794080

二、应用题

（1）（46）（7416531426403886652734）←初态

（4674）（16531426403886652734）

（164674）（531426403886652734）

（16465374）（1426403886652734）

（1416465374）（26403886652734）

（141626465374）（4