数据结构 习题参考答案.docx

1、数据结构 习题参考答案第1章一、15：BCCDC 610：ABABC 1115：BBDCB 1617：AD二、1.数据的逻辑结构,数据的存储结构,数据的运算及实现；2.集合结构,线性结构,树形结构,图形结构；3.规模；4.抽象数据类型；5.顺序存储结构，索引存储结构，散列存储结构；6.时间复杂度；7.顺序存储，链式存储；8. 插入,删除,定位三、简答题1.略；2.略；3.O(n),O(1),O(n2),O(n),O(n3),O(n)4.第2章一、15：BBBDB 610：BAAAA 1113：ABB二、1.顺序，链式；2.前驱,后继;3.顺序表,链表;4.随机存取,空间利用率高;5.插入,删除

2、;6.(n+1)/2,元素的插入位置;7.O(1),随机存取;8.使空表和非空表的算法一致;9.也,不一定;10.链式,顺序;11.单向链表,双向链表,循环链表;12.p的前驱,O(n);13.表头指针三、问答题（略）四、算法及程序设计题1.解答：算法分两步执行，首先在单链表中找到值为x的结点*p和它的直接前驱结点*q，然后再删除直接前驱结点*q即可。删除时，可将*p结点的数据域的值赋给*q结点，然后将*p结点删除。typedef struct Node ElemType data; struct Node *next;LNode;void ListDelete_Link(LNode *L,i

3、nt x)/L是带头结点的单链表 LNode *p,*q; int j; q=L; p=L-next; j=0; while(p&p-data!=x) /查找数据域值为x的结点 q=p;j+; p=p-next; if(p=NULL) printf(x不在L中); return; /查找失败 if(j=0) printf(x 是第一个结点，它没有前驱);return;/无前驱 q-data=x; /将p的值存入q中 q-next=p-next; /删除的是结点p free(p);/ListDelete_Link2.解答：本题是遍历通过该链表的每个结点，每遇到一个结点，结点个数加1，结点个数存储

4、在变量n中。void Count(LNode *head) LNode *p; int n=0; p=head-next; while(p!=NULL) if(p-data=x) n+; p=p-next; return(n);/Count3.解答：本题算法的思想是先建立一个待插入的结点，然后依次与链表中的各结点的数据域比较大小，找到插入该结点的位置，最后插入该结点。LNode *OrderListInsert_Link(LNode *head,int x) LNode *t,*p,*q; t=(LNode*)malloc(sizeof(LNode); /建立一个待插入的结点 t-data=x

5、; t-next=NULL; q=head; p=head-next; while(p& xp-data) q=p; p=p-next;/查找插入位置 t-next=p; q-next=t; /将t结点插入到q和p之间 return(head);/OrderListInsert_Link第3章一、15：DDDBA 610：CACCC 1115：ABDCA 1617：CC二、1.O(n),O(1),O(1),O(n);2.线性,任何,栈顶,队尾,队首;3.不可能;4.先进后出;5.先进先出;三、应用题1.14种出栈序列：ABCD,ABDC,ACBD,ACDB,ADCB,BACD,BADC,BCA

6、D,BCDA,BDCA,CBAD,CBDA,CDBA,DCBA2.略四、算法及程序设计题1.解答#include#define MAXSIZE 50typedef struct char datasMAXSIZE; int top;SqStack;SqStack *s;void reverse(SqStack *p,int flag) /将输入的数据序列用递归方法逆置输出 char ch; if(flag) ch=getchar(); if(ch!=) p-datas+p-top=ch; flag=1; else flag=0; else ch=p-datasp-top-; printf(%c

7、,ch); flag=0; if(p-top=0) reverse(p,flag);/如果不是结束符号则递归main() int flag1=1; s-top=-1; printf(please input value:n); reverse(s,flag1);2.解答本题是对一个循环链队列做插入和删除运算，假设不需要保留被删除结点的值和不需要回收结点，可将算法描述如下：(1) 入队void EnLinkQueue(QNode *q,ElemType x) LinkQList *rear,*p; p=(QNode*)malloc(sizeof(QNode); if(rear=NULL) rea

8、r=p; rear-next=p);/链接成循环链表 else p-next=rear-next; rear-next=p; rear=p;/若条件成立，则建立循环链队列的第一个结点，否则在队尾插入*p结点/EnLinkQueue(2) 出队void DeLinkQueue(QNode *q) LinkQList *rear; if(rear=NULL) printf(underflown); if(rear-next=rear) rear=NULL; else rear-next=rear-next-next; /rear-next指向的结点为循环链队列的队头结点/DeLinkQueue3.

9、解答此算法中包括栈初始化操作，读入字符，压栈和出栈等操作。typedef struct SNode char data; struct SNode *next;SNode,*LinkStack;void Matcher(SNode *ls) SNode *p; char ch,c; while(ch=getchar()!=n) if(ch=( | ch= | ch=) p=(SNode*)malloc(sizeof(SNode); p-data=ch; p-next=ls; ls=p; else p=ls; c=p-data; ls=ls-next; free(p); if(!(c=( & c

10、h=)|(c= & ch=)|(c= & ch=) return(0); return(1);/Matcher第4章一、15:DDCCD二、1.顺序定长存储方式,堆分配存储方式；2.两个串的长度相等且对应位置的字符相同；3.零个字符的串，零；4.由一个或多个空格字符组成的串，其包含的空格个数；5.14；6.GOODBYE！；7.3，CDE；8.13，studentteacher，Im；三、问答题（略）四、算法及程序设计题1.void Search(LinkString x,LinkString y) p=x-next; while(p!=NULL) q=y-next; while(q!=NUL

11、L) if(p-data=q-data) q=q-next; else return(该字符不在y串中); p=p-next; if(p=NULL) return(串x中的字符全都在串y中);/Search 2.解答：在串S中找到最先出现的子串ab，p指向data域值为a的结点，其后为data域值为b的结点。将它们的data域值分别改为x和z，再创建一个data域值为y的结点，将其插入到*p之后。void Repl(LinkString S) LinkString *p=S-next,*q; int find=0; while(p-next!=NULL & find=0) if(p-data=

12、a & p-next-data=b) p-data=x;p-next-data=z; q=(LinkString *)malloc(sizeof(LinkString); q-data=y;q-next=p-next;p-next=q; find=1; else p=p-next;/Rep1第5章一、15：CBCBA 610：ADDCA二、1.Loc(a00)+(i*n+j)*k;2.行优先存储,列优先存储;3.稀疏矩阵;4.1060;5.压缩矩阵;6.1168;7.第一个元素，子表;8.下三角，n(n+1)/2;9.y,( )三、简答题（略） 四、算法设计题（略）第6章一、1.B（二叉树并非

13、是树的特殊情形，尽管两者有许多相同之处，但是它们是两种不同的数据结构）；2.D；3.C；4.C；5.B；6.C；7.D；8.C；9.D；10.A；11.C；12.D二、1.,2i,2i+1；2.4；3.33；4.后面；5.中根,先根；6.12,5,7；7.68；8.遍历；9.线索化;10.完全二叉树,哈夫曼树;11.结点的度;12.深度;13.32;14.中序序列;15.13，3三、应用题1.哈夫曼树为： 2. 构造的哈夫曼树为：带权路径长度为：WPL=(3+4+5+6)2=363.先序遍历序列为：ABCDGEIHFK4.该顺序存储结构对应的二叉树为： 前序遍历结果：EADCBJFGHI 中序

14、遍历结果：ABCDJEFHGI 后序遍历结果：BCJDAHIGFE G的父结点为:F;左右孩子为:H,I;度为2。 由二叉树还原的森林如下所示：四、算法与程序设计题1.void inorder(BTNode *T) BTNode *p,*sMAXSIZE; int top=0;p=T; while(p|top0) while(p) s+top=p;p=p-lchild; if(top0) p=stop-; printf(p-data); p=p-rchild; 2.void count(BTNode *T,int *s) if(T!=NULL) if(T-lchild & T-rchild)

15、*s+;count(T-lchild,s);count(T-rchild,s);第7章一、选择题15：CDCBA 610：ADDCB 1115：BBDBC 1620：BDACC二、填空题1.邻接矩阵;2.存在环路的图;3.n+2e;4.n-1;5.邻接表;6.邻接矩阵、邻接表;7.前序三、应用题1.各顶点的入度和出度为： 图中有8条弧 邻接矩阵与邻接表如下所示顶点入度出度 v020v131v222v303v4122.用Prim算法从顶点1开始求最小生成树的过程如下所示：用Prim算法求最小生成树，在寻找下一条最小边时，需要扫描未并入的所有顶点，每并入一个顶点就要做一次全面扫描，故时间复杂度为O

16、(n2)。3. 按深度优先搜索遍历得到的顶点序列：0,1,2,8,5,6,7,9,4,3按广度优先搜索遍历得到的顶点序列：0,1,4,2,6,3,8,5,7,94. 按照Kruskal算法网的最小生成树的产生过程如下：5.由上述求解过程可知，从v0到其余各顶点的最短路径为：路径长度v0,v210v0,v430v0,v4,v350v0,v4,v3,v560v16.（1）各事件的最早发生时间ve和最迟发生时间vl为：事件v1v2v3v4v5v6v7v8v9v10v11Ve0345791511212228vl064157192111212228（2）各活动的最早开始时间e和最迟开始时间l为：活动a1

17、a2a3a4a5a6a7a8a9a10a11a12a13a14a15e00334457791511112122l3013641415137192118112122由此可以看出关键活动有：a2,a5,a9,a13,a14,a15，因此关键路径为：(v1,v3,v5,v8,v9,v10,v11)。四、（略）第8章一、15: B C C D C 610:D B B B A二、1.1,2,4,log2n；2.索引表，主表，和；3.越大，越小，4.顺序，有序，顺序或链式存储；513/2,(log213)-1三、应用题1. 解： 顺序查找：ASL=（n+1）/2=13 折半查找：ASL=（1*1+2*2+

18、4*3+8*4+9*5+1*6）/25=100/25=4 分块查找：ASL=（2+3+4+5+6）+（3+4+5+6+7）+（4+5+6+7+8）+（5+6+7+8+9+）+（6+7+8+9+10）/25=150/25=62. 解：计算散列地址：H(19)=19%13=6；H(01)=01%13=1；H(23)=23%13=10；H(14)=14%13=1(冲突)，H1=(1+12)%19=2；H(55)=55%13=3；H(20)=20%13=7； H(84)=84%13=6(冲突)，H1=(6+12)%19=7（冲突），H2=(6-12)%19=5；H(27)=27%13=1（冲突），H1

19、=(1+12)%19=2（冲突），H2=(1-12)%19=0；H(68)=68%13=3（冲突），H1=(3+12)%19=4；H(11)=11%13=11； H(10)=10%13=10（冲突），H1=(10+12)%19=11（冲突），H2=(10-12)%19=9；H(77)=77%13=12。 散列表为：012345678910-11121314151617182701145568841920102311773. 解：计算散列地址：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)

20、=94%13=3（冲突），H1=(3+1)%13=4； H(25)=25%13=12；H(36)=36%13=10（冲突），H1=(10+1)%13=11（冲突），H2=(10+2)%13=12（冲突），H3=(10+3)%13=0；H(18)=18%13=5；H(70)=70%13=5（冲突），H1=(5+1)%13=6（冲突），H2=(5+2)%13=7； 散列表为： 地址0123456789101112关键字36299418327048756325查找成功的平均查找长度：ASL=（7*1+1*2+1*3+1*4）/10=16/10=1.6查找失败的平均查找长度：ASL=(2+1+1+6+

21、5+4+3+2+1+5+4+3+2)/13=3四、算法题1.解： int BinSearch(ListSq L, int low, int high, keytype K) while (low=high) int mid=(low+high)/2; /求出待查区间中间点元素下标if (K=L.emid.key) return mid;/ 查找成功返回元素下标else if (Knext;int n=1;while(p&(p-data.key!=s) p=p-next; n+; if(p) return n;else return 1;3.解void level(BSTree root,p)

22、int level=0;if(!root) return(0);else Level+; while(root-key!=p-key) if (p-keykey) root=root-lchild; else root=root-rchild; return(level); 第9章一、 选择题B B B C C C C B A C二、填空题1.直接插入排序，直接选择排序；2.5，4，8；3.快速排序，归并排序，希尔排序，选择排序，快速排序，堆排序；4. n-1，从小到大排列，从大到小排列，n(n-1)/2；5. 3三、应用题1稳定的排序算法有直接插入排序、折半插入排序、冒泡排序、归并排序和基数

23、排序。不稳定的排序算法有希尔排序、直接选择排序、堆排序、快速排序。2.插入20的过程：1 3920：high =mid-1=3;low=high ;mid=(low+high )/2=4/2=22 13high ;查找过程结束，插入位置为3。最终结果为：6 13 20 28 39 41 72 85（1）插入排序所要进行的比较次数与待排序的记录的初始状态有关。若初始状态基本有序，每次查找时都会搜索到有序表的最后一个元素才找到插入位置。若每次插入的元素在有序表中的插入位置靠中间，则查找次数最少。（2）在一些特殊情况下，二分法插入排序比直接插入排序要执行更多的比较。这句话是对的。若初始状态基本有序，

24、则折半插入排序，每次查找时都会搜索到有序表的最后一个元素才找到插入位置。直接插入排序则每次只比较一次就找到合适位置。3.答：因排序的元素个数很大，所以需要采用排序速度较快的排序方法。排序速度比较快的排序方法有快速排序、堆排序、归并排序和基数排序等。其中快速排序、归并排序和基数排序都是在排序结束后才能确定数据元素的全部序列，而排序过程中无法知道部分连续位置上的最终元素。但堆排序则每次输出一个堆顶元素（即最大或最小元素），然后对堆进行再调整，保证堆顶元素总是剩下元素的最大或最小的，从而可知，若在大量数据的文件中，只选取排序后的前几名，采用堆排序最合适。4.（1）100，85，95，75，80，60

25、，82，40，20，10，65; 是堆。 （2）100，95，85，82，80，75，65，60，40，20，10; 是堆。 （3）100，85，40，75，80，60，65，95，82，10，20; 不是堆 调整以后的堆为：100，95，65，85，80，60，40，75，82，10，20 （4）10，20，40，60，65，75，80，82，85，95，100; 是堆。四、算法题1. 假设待排序序列以单链表的形式存储，头指针为head，编写选择排序算法。#include struct RtypeKeyType key; /关键字域;struct LnodeElemtype data ;st

26、ruct Lnode * next ;void selectsort( Lnode *L) Lnode *p,*q,*r;Rtype temp;for (p=L-next;p-next!=NULL;p=p-next)q=p; for (r=p-next;r!=NULL;r=r-next) if (q-datar-data) q=r ; if (p!=q) temp=p-data; p-.data=q-data; q-data=temp; 2. 设计一个双向冒泡排序算法，即在排序过程中交替改变扫描方向。struct Rtype KeyType key; /关键字域;struct ListSq Rtype e MAXSIZE ; / 0号单元空闲，元素从1号单元开始存放int len ; void dbubblesort(ListSq r, int n) int i,j,flag;Rtype temp;flag=1; i=0;while(flag) flag=0;for(j=n-i;ji;j-) if (r.ej.keyr.ej-1.key) flag=a; temp=r.ej; r.ej= r.ej-1; r.ej-1=temp; for(j=i;jn-1;j+) if