数据结构(习题三)
最新数据结构习题课3讲解学习
0 50 1 10 3 -30 1 20 3 -60 35
a[0] 0 0 50 a[1] 1 0 10 a[2] 1 2 20 a[3] 3 0 -30 a[4] 3 2 -60 a[5] 3 3 5
03 10 22 31
num
00 13 23 35
pos
0
TP3[处理三元组表]
3
FOR i ← 0 TO t-1 DO
20
A[4] 3
2
-60
A[5] 3 3
5
B[4] 2
3
-60
B[5] 3 3
5
算法的关键是求出A中元素在B中的位置
Bnubmer = 0
FOR i=0 TO Cols(A) DO
FOR j=0 TO t DO
IF col(A[j])=i Then
(row(B[Bnumber])=i
col(B[Bnumber])=row(A[j])
算法: TRANSPOSE(A. B)
TP1[初始化] /*声明A的转置矩阵B,使得B的行数等于 A的列数,B的列数等于A的行数,B中非 0元素的个数等于A中非0元素的个数*/ n←Rows(B)←Cols(A). Cols (B)←Rows(A). t←Count(B)← Count(A).
TP2
row(B[k]) ←col(A[i]).
val(B[k]) ← val(A[i]).
pos[p]← pos[p]+1 ).
a[0] 0 0 50 a[1] 1 0 10 a[2] 1 2 20 a[3] 3 0 -30 a[4] 3 2 -60 a[5] 3 3 5
0 0 50 0 1 10
2 1 20
数据结构 判断题
《数据结构》习题库之三:判断题1. 程序就是算法,但算法不一定是程序。
()2. 线性表只能采用顺序存储结构或者链式存储结构。
()3. 线性表的链式存储结构是通过指针来间接反映数据元素之间逻辑关系的。
()4. 除插入和删除操作外,数组的主要操作还有存取、修改、检索和排序等。
()5. 稀疏矩阵中0元素的分布有规律,因此可以采用三元组方法进行压缩存储。
()6. 不管堆栈采用何种存储结构,只要堆栈不空,可以任意删除一个元素。
()7. 确定串T在串S中首次出现的位置的操作称为串的模式匹配。
()8. 深度为h的非空二叉树的第i层最多有2i-1 个结点。
()9. 满二叉树就是完全二叉树。
()10. 已知一棵二叉树的前序序列和后序序列可以唯一地构造出该二叉树。
()11. 非空二叉排序树的任意一棵子树也是二叉排序树。
()12. 对一棵二叉排序树进行前序遍历一定可以得到一个按值有序的序列。
()13. 若有向图G=(V,E)的拓扑序列不唯一,则图中必须有两条弧和。
()14. 散列表的查找效率主要取决于所选择的散列函数与处理冲突的方法。
()15. 序列初始为逆序时,泡排序法所进行的元素之间的比较次数最多。
()16. 算法一定要有输入和输出。
()17. 算法分析的目的旨在分析算法的效率以求改进算法。
()18. 非空线性表中任意一个数据元素都有且仅有一个直接后继元素。
()19. 数据的存储结构不仅有顺序存储结构和链式存储结构,还有索引结构与散列结构。
()20. 线性链表中各个链结点之间的地址不一定要连续。
()21. 若频繁地对线性表进行插入和删除操作,该线性表采用顺序存储结构更合适。
()22. 若线性表采用顺序存储结构,每个数据元素占用4个存储单元,第12个数据元素的存储地址为144,则第1个数据元素的存储地址是101。
()23. 若长度为n的线性表采用顺序存储结构,删除表的第i个元素之前需要移动表中n-i+1个元素。
()24. 符号link(p)出现在表达式中表示p所指的那个结点的内容。
数据结构习题三(答案)
哈夫曼编码: a:11 b:101 c:010 d:1001 e:011 f:00 g:1000 2) 等长编码至少需要3 bit 哈夫曼编码WPL=0.31*2+0.16*3+0.10*3+0.08*4+0.11*3+0.20*2+0.04*4=2.61 压缩率=1-2.61/3=13% 4.程序设计题 1)创建一任意二叉树,统计某子树下值为奇数和偶数结点的个数。 #define INT #include"c1.h" #ifdef CHAR typedef char TElemType; TElemType Nil=' '; /* 字符型以空格符为空*/ #endif #ifdef INT typedef int TElemType; TElemType Nil=0; /* 整型以0为空*/ #endif #include"c6-2.h" #include"bo6-2.c" void GetLeafCounts(BiTree T,int *n,int *m) {
文档之家的所有文档均为用户上传分享文档之家仅负责分类整理如有任何问题可通过上方投诉通道反馈
数据结构习题三(答案)
数据结构习题(三) 学号________ 姓名_______ 课堂号(_________) 1.选择题 1)若一棵二叉树具有10个度为2的结点,5个度为1的结点,则度为0的结点个数是( B )A.9 B.11 C.15 D.不确定 2)设森林F中有三棵树,第一,第二,第三棵树的结点个数分别为M1,M2和M3。与森林 F对应的二叉树根结点的右子树上的结点个数是( D ) A.M1 B.M1+M2 C.M3 D.M2+M3 3)二叉树的第I层上最多含有结点数为( C ) A.2I B. 2I-1-1 C. 2I-1 D.2I -1 4)在一棵高度为k的满二叉树中,结点总数为( C ) A.2k-1 B.2k C.2k-1 D.?log2k?+1 5)利用二叉链表存储树,则根结点的右指针是( C )。 A.指向最左孩子 B.指向最右孩子 C.空 D.非空 6)已知一棵二叉树的前序遍历结果为ABCDEF,中序遍历结果为CBAEDF,则后序遍历的结果 为( A )。 A.CBEFDA B. FEDCBA C. CBEDFA D.不定 7)n个结点的线索二叉树上含有的线索数为( C ) A.2n B.n-l C.n+l D.n 8)由3 个结点可以构造出多少种不同的二叉树?( D ) A.2 B.3 C.4 D.5 9)某二叉树中序序列为A,B,C,D,E,F,G,后序序列为B,D,C,A,F,G,E。二叉树对应的森林 包括多少棵树( B ) A.l B.2 C.3 D.概念上是错误的 10)设F是一个森林,B是由F变换得的二叉树。若F中有n个非终端结点,则B中右指针 域为空的结点有( C )个。 A. n-1 B.n C. n+1 D. n+2 11)下面几个符号串编码集合中,不是前缀编码的是( B )。 A.{0,10,110,1111} B.{11,10,001,101,0001} C.{00,010,0110,1000} D.{b,c,aa,ac,aba,abb,abc} 2.填空题 12)树在计算机内的表示方式有__双亲表示法_,___孩子表示法___,___孩子兄弟表示法/ 二叉链表表示法_____。 13)在二叉树中,指针p所指结点为叶子结点的条件是_p->lchild==NULL && p->rchild==NULL________________。
数据结构与算法设计-习题1-3
int
data;
struct Lnode *next;
// 数据域 // 指针域
} LNode, *LinkList; LinkList la, lb; // 单链表的头指针 请用 la 和 lb 中的结点合并生成一个新的非 递增的有序单链表 lc。合并完成后,原来的 la 和 lb 成为空链表。
作者 (时间 2000年) 北京理工大学计算机科学工程系 秦怀青 email qinhq010@
正确且高效的算法如下: Status DeleteK(SqList &a ,int i, int k) {//设线性表元素从a.base[1]起存储,从第i个元素起
删除k个元素。
if ( i<1|| k< 0 || (i+k)>a.length) return ERROR;
for ( j=i+k;j<=a.length; ++j)
操作步骤
1) 建空表 Lc; 2) 依次从 La 或 Lb 中“摘取”元素值较小的
结点插入到 Lc 表中第一个结点之前直至其 中一个表变空为止; 3) 继续将 La 或 Lb 其中一个表的剩余结点插 入在 Lc 表的表头结点之后; 4) 释放 La 表和 Lb 表的表头结点。
作者 (时间 2000年) 北京理工大学计算机科学工程系 秦怀青 email qinhq010@
单链表中逻辑上相邻的元素的物理位置 不一定 紧邻。
(3)在单链表中,除了头结点外,任一结点的存储位置 由 该结点的直接前趋 指示。
(4)在单链表中设置头结点的作用是
在表的第一个元素结点之前插入新元素结点或删除 第一个元素结点不需修改头作指者 针(时间 2000年)
数据结构第三章习题答案解析
第三章习题1.按图3.1(b)所示铁道(两侧铁道均为单向行驶道)进行车厢调度,回答:⑴如进站的车厢序列为123,则可能得到的出站车厢序列是什么?⑵如进站的车厢序列为123456,能否得到435612和135426的出站序列,并说明原因。
(即写出以“S”表示进栈、以“X”表示出栈的栈操作序列)。
2.设队列中有A、B、C、D、E这5个元素,其中队首元素为A。
如果对这个队列重复执行下列4步操作:(1)输出队首元素;(2)把队首元素值插入到队尾;(3)删除队首元素;(4)再次删除队首元素。
直到队列成为空队列为止,得到输出序列:(1)A、C、E、C、C (2) A、C、E(3) A、C、E、C、C、C (4) A、C、E、C3.给出栈的两种存储结构形式名称,在这两种栈的存储结构中如何判别栈空与栈满?4.按照四则运算加、减、乘、除和幂运算(↑)优先关系的惯例,画出对下列算术表达式求值时操作数栈和运算符栈的变化过程:A-B*C/D+E↑F5.试写一个算法,判断依次读入的一个以@为结束符的字母序列,是否为形如‘序列1& 序列2’模式的字符序列。
其中序列1和序列2中都不含字符’&’,且序列2是序列1的逆序列。
例如,‘a+b&b+a’是属该模式的字符序列,而‘1+3&3-1’则不是。
6.假设表达式由单字母变量和双目四则运算算符构成。
试写一个算法,将一个通常书写形式且书写正确的表达式转换为逆波兰式。
7.假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的队列初始化、入队列和出队列的算法。
8.要求循环队列不损失一个空间全部都能得到利用, 设置一个标志域tag , 以tag为0或1来区分头尾指针相同时的队列状态的空与满,请编写与此结构相应的入队与出队算法。
9.简述以下算法的功能(其中栈和队列的元素类型均为int):(1)void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);}for(i=1; i<=n; i++)Push(&S, A[i]);}(2)void proc_2(Stack S, int e){ Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}(3)void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q,d)}}实习题1.回文判断。
数据结构练习题第三章栈、队列和数组习题及答案
第三章栈、队列和数组一、名词解释:1.栈、栈顶、栈底、栈顶元素、空栈2.顺序栈3.链栈4.递归5.队列、队尾、队头6.顺序队7.循环队8.队满9.链队10.随机存储结构11.特殊矩阵12.稀疏矩阵13.对称方阵14.上(下)三角矩阵二、填空题:1.栈修改的原则是_________或称________,因此,栈又称为________线性表。
在栈顶进行插入运算,被称为________或________,在栈顶进行删除运算,被称为________或________。
2.栈的基本运算至少应包括________、________、________、________、________五种。
3.对于顺序栈,若栈顶下标值top=0,此时,如果作退栈运算,则产生“________”。
4.对于顺序栈而言,在栈满状态下,如果此时在作进栈运算,则会发生“________”。
5.一般地,栈和线性表类似有两种实现方法,即________实现和________实现。
6.top=0表示________,此时作退栈运算,则产生“________”;top=sqstack_maxsize-1表示________,此时作进栈运算,则产生“________”。
7.以下运算实现在顺序栈上的初始化,请在________处用适当的句子予以填充。
int InitStack(SqStackTp *sq){ ________;return(1);}8.以下运算实现在顺序栈上的进栈,请在________处用适当的语句予以填充。
Int Push(SqStackTp *sq,DataType x){ if(sp->top==sqstack_maxsize-1}{error(“栈满”);return(0);}else{________________:________________=x;return(1);}}9.以下运算实现在顺序栈上的退栈,请在________________用适当句子予以填充。
2021年小学信息技术教师数据结构练习题及参考答案(三)
2021年小学信息技术教师专业技能数据结构练习题及参考答案(三)1.每个结点只存储一个数据元素,存储结点存放在连续的存储空间,该存储方式是( A )存储方式。
A.顺序 B. 链式 C. 索引 D. 散列2.对于顺序表的优缺点,下面说法错误的是( C )。
A.无需为表示节点间的逻辑关系而增加额外的存储空间。
B.可以方便的随机存取表中的任一结点。
C.删除和插入运算较方便。
D.由于顺序表要求占用连续的空间,存储分配只能预先进行(静态分配)。
3.下面( B )的时间复杂性最好,即执行时间最短。
A.O(n)B.O(log2n)C.O(nlog2n)D.O(n2)4.在带头结点的单链表h中,若要向表头插入一个由指针p所指向的结点,则执行( D )。
A. h=p, p->next=hB. p->next=h, h=pC. p->next=h, p=hD. p->next=h->next, h->next=p5.与线性表的链接存储相符的特性是( A )。
A.插入和删除操作灵活B.可随机访C.存储空间静态分配D.不需另外开辟空间来保存元素间的关系6.用某种排序方法对序列(25,84,21,47,15,27,68,35,20)进行排序,记录序列的变化情况如下: 25 84 21 47 15 27 68 35 20 20 15 21 25 4727 68 35 84 15 20 21 25 35 27 47 68 84 15 20 21 25 27 35 47 68 84 则采用的排序方法是( C )。
A.直接选择排序 B. 冒泡排序 C. 快速排序 D. 二路归并排序7.下列关于线性表的叙述中,不正确的是( C )。
A.线性表是n个结点的有穷序列B.线性表可以为空表C.线性表的每一个结点有且仅有一个前趋和一个后继D.线性表结点间的逻辑关系是1:1的联系8.将长度为m的单链表链接在长度为n的单链表之后的算法的时间复杂度为( B )。
第三章栈和队列习题-数据结构
第三章栈和队列习题-数据结构习题三栈和队列一单项选择题1.在作进栈运算时,应先判别栈是否(①),在作退栈运算时应先判别栈是否(②)。
当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为(③)。
①,②:A.空B.满C.上溢D.下溢③:A.n-1B.nC.n+1D.n/22.若已知一个栈的进栈序列是1,2,3,,n,其输出序列为p1,p2,p3,...,pn,若p1=3,则p2为()。
A可能是2B一定是2C可能是1D一定是13.有六个元素6,5,4,3,2,1的顺序进栈,问下列哪一个不是合法的出栈序列?()A.543612B.453126C.346521D.2341564.设有一顺序栈S,元素1,2,3,4,5,6依次进栈,如果6个元素出栈的顺序是2,3,4,6,5,1,则栈的容量至少应该是()A.2B.3C.5D.65.若栈采用顺序存储方式存储,现两栈共享空间V[1..m],top[i]代表第i个栈(i=1,2)栈顶,栈1的底在v[1],栈2的底在V[m],则栈满的条件是()。
A.|top[2]-top[1]|=0B.top[1]+1=top[2]C.top[1]+top[2]=mD.top[1]=top[2]6.执行完下列语句段后,i值为:()intf(int某){return((某>0)某某f(某-1):2);}inti;i=f(f(1));A.2B.4C.8D.无限递归7.表达式3某2^(4+2某2-6某3)-5求值过程中当扫描到6时,对象栈和算符栈为(),其中^为乘幂A.3,2,4,1,1;(某^(+某-B.3,2,8;(某^-C.3,2,4,2,2;(某^(-D.3,2,8;(某^(-8.用链接方式存储的队列,在进行删除运算时()。
A.仅修改头指针B.仅修改尾指针C.头、尾指针都要修改D.头、尾指针可能都要修改9.递归过程或函数调用时,处理参数及返回地址,要用一种称为()的数据结构。
《数据结构》习题集:第3章 栈和队列
第3章栈和队列一、选择题1.栈结构通常采用的两种存储结构是(A )。
A、顺序存储结构和链表存储结构B、散列和索引方式C、链表存储结构和数组D、线性链表结构和非线性存储结构2.设栈ST 用顺序存储结构表示,则栈ST 为空的条件是( B )A、ST.top-ST.base<>0B、ST.top-ST.base==0C、ST.top-ST.base<>nD、ST.top-ST.base==n3.向一个栈顶指针为HS 的链栈中插入一个s 结点时,则执行( C )A、HS->next=s;B、s->next=HS->next;HS->next=s;C、s->next=HS;HS=s;D、s->next=HS;HS=HS->next;4.从一个栈顶指针为HS 的链栈中删除一个结点,用x 保存被删除结点的值,则执行( C)A 、x=HS;HS=HS->next;B 、HS=HS->next;x=HS->data;C 、x=HS->data;HS=HS->next;D 、s->next=Hs;Hs=HS->next;5.表达式a*(b+c)-d 的后缀表达式为( B )A、abcdd+-B、abc+*d-C、abc*+d-D、-+*abcd6.中缀表达式A-(B+C/D)*E 的后缀形式是( D )A、AB-C+D/E*B、ABC+D/E*C、ABCD/E*+-D、ABCD/+E*-7.一个队列的入列序列是1,2,3,4,则队列的输出序列是( B )A、4,3,2,1B、1,2,3,4C、1,4,3,2D、3,2,4,18.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值,已知其头尾指针分别是front 和rear,则判定此循环队列为空的条件是()A、Q.rear-Q.front==nB、Q.rear-Q.front-1==nC、Q.front==Q.rearD、Q.front==Q.rear+19.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值,已知其头尾指针分别是front 和rear,则判定此循环队列为满的条件是()A、Q.front==Q.rearB、Q.front!=Q.rearC、Q.front==(Q.rear+1)%nD、Q.front!=(Q.rear+1)%n10.若在一个大小为6 的数组上实现循环队列,且当前rear 和front 的值分别为0 和3,当从队列中删除一个元素,再加入两个元素后,rear 和front 的值分别为()A、1,5B、2, 4C、4,2D、5,111.用单链表表示的链式队列的队头在链表的()位置A、链头B、链尾C、链中12.判定一个链队列Q(最多元素为n 个)为空的条件是()A、Q.front==Q.rearB、Q.front!=Q.rearC、Q.front==(Q.rear+1)%nD、Q.front!=(Q.rear+1)%n13.在链队列Q 中,插入s 所指结点需顺序执行的指令是()A 、Q.front->next=s;f=s;B 、Q.rear->next=s;Q.rear=s;C 、s->next=Q.rear;Q.rear=s;D 、s->next=Q.front;Q.front=s;14.在一个链队列Q 中,删除一个结点需要执行的指令是()A、Q.rear=Q.front->next;B、Q.rear->next=Q.rear->next->next;C、Q.front->next=Q.front->next->next;D、Q.front=Q.rear->next;15.用不带头结点的单链表存储队列,其队头指针指向队头结点,队尾指针指向队尾结点,则在进行出队操作时()A、仅修改队头指针B、仅修改队尾指针C、队头尾指针都要修改D、队头尾指针都可能要修改。
数据结构习题第3章
第3章栈和队列一、选择题1. 栈中元素的进出原则是( )A.先进先出B.后进先出C.栈空则进D.栈满则出2. 已知一个栈的进栈序列为1, 2, …, n,其输出序列是p1, p2, … , p n ,若p1=n,则p i=()A. iB. n-iC. n-i+1D.不确定3. 一个栈的输入序列为:a b c d e,则下列不可能是栈的输出序列的是()。
A. b c d a eB. e d a c bC. b c a d eD. a e d c b4. 判定一个栈ST(最多元素为m0)为空的条件是( )A.ST->top<>0 B.ST->top=0 C.ST->top<>m0 D.ST->top=m0 5. 判定一个队列QU(最多元素为m0)为满队列的条件是( )A.QU->rear -QU->front = = m0 B.QU->rear -QU->front -1= = m0 C.QU->front = = QU->rear D.QU->front = = QU->rear+16.数组Q[n]用来表示一个循环队列,f为当前队列头元素的前一位置,r为队尾元素的位置,假定队列中元素的个数小于n,计算队列中元素的公式为( )A. r-fB.(n+f-r)% nC.n+r-fD.(n+r-f)% n7. 栈和队列的共同点是()。
A. 都是先进先出B. 都是先进后出C. 只允许在端点处插入和删除元素D. 没有共同点8. 用单链表表示的链式队列的队头在链表的()位置。
A.表头B.表尾C.中间9. 设计一个判别表达式中左,右括号是否配对出现的算法,采用()结构最佳。
A.线性表的顺序存储结构 B. 队列C. 线性表的链式存储结构D. 栈10. 用不带头结点的单链表存储队列时,其队头指针指向队头结点,其队尾指针指向队尾结点,则在进行删除操作时( )。
数据结构期末复习题3
一、填空题1.数据的最小单位是( C )。
A. 数据项B. 数据类型C.数据元素D.数据变量2.算法指的是( D )。
A.计算机程序 B.解决问题的计算方法C.排序算法 D.解决问题的有限运算序列3.下面关于线性表的叙述错误的是(C )。
A. 线性表采用顺序存储必须占用一片连续的存储空间B. 线性表采用链式存储不必占用一片连续的存储空间C. 线性表采用链式存储便于插入和删除操作的实现D. 线性表采用顺序存储便于插入和删除操作的实现5.设哈夫曼树中的叶子结点总数为m,若用二叉链表作为存储结构,则该哈夫曼树中总共有()个空指针域。
A. 2m-1B. 2mC. 2m+1D. 4m6.设顺序循环队列Q[0:M-1]的头指针和尾指针分别为F和R,头指针F总是指向队头元素的前一位置,尾指针R总是指向队尾元素的当前位置,则该循环队列中的元素个数为()。
A. R-FB. F-RC. (R-F+M)%MD. (F-R+M)%M7.设某棵二叉树的中序遍历序列为ABCD,前序遍历序列为CABD,则后序遍历该二叉树得到序列为()。
A. BADCB. BCDAC. CDABD. CBDA8.设某完全无向图中有n个顶点,则该完全无向图中有()条边。
A. n(n-1)/2B. n(n-1)C. n2D. n2-19. 满二叉树_______二叉树。
A. 一定是完全B.不一定是完全C.不是D.不是完全10.设某棵二叉树中有2000个结点,则该二叉树的最小高度为()。
A. 9B. 10C. 11D. 1211.设某有向图中有n个顶点,则该有向图对应的邻接表中有()个表头结点。
A. n-1B. nC. n+1D. 2n-112.设一组初始记录关键字序列(5,2,6,3,8),以第一个记录关键字5为基准进行一趟快速排序的结果为()。
A. 2,3,5,8,6B. 3,2,5,8,6C. 3,2,5,6,8D. 2,3,6,5,813.栈和队列的共同特点是( A )。
数据结构习题及答案(3)
数据结构习题及答案(3)第九章排序⼀、选择题1.在所有排序⽅法中,关键字⽐较的次数与记录得初始排列次序⽆关的是()(A)希尔排序(B)起泡排序(C)插⼊排序(D)选择排序参考答案:D2.设有1000个⽆序的元素,希望⽤最快的速度挑选出其中前10个最⼤的元素,最好()排序法。
(A)起泡排序(B)快速排序(C)堆排序(D)基数排序参考答案:C3.在待排序的元素序列基本有序的前提下,效率最⾼的排序⽅法是()(A)插⼊排序(B)选择排序(C)快速排序(D)归并排序参考答案:A4.⼀组记录的排序码为(46,79,56,38,40,84),则利⽤堆排序的⽅法建⽴的初始推为()。
(A)79,46,56,38,40,80 (B)84,79,56,38,40,46(C)84,79,56,46,40,38 (D)84,56,79,40,46,38参考答案:B5.⼀组记录的关键码为(46,79,56,38,40,84),则利⽤快速排序的⽅法,以第⼀个记录为基准得到的⼀次划分结果为()。
(A)38,40,46,56,79,84(B)40,38,46,79,56,84(C)40,38,46,56,79,84(D)40,38,46,84,56,79参考答案:C6.⼀组记录的排序码为(25,48,16,35,79,82,23,40,36,72),其中含有5个长度为2的有序表,按归并排序的⽅法对该序列进⾏⼀趟归并后的结果为()。
(A)16,25,35,48,23,40,79,82,36,72(B)16,25,35,48,79,82,23,36,40,72(C)16,25,48,35,79,82,23,36,40,72(D)16,25,35,48,79,23,36,40,72,82参考答案:A7.排序⽅法中,从未排序序列中依次取出元素与⼰排序序列(初始时为空)中的元素进⾏⽐较,将其放⼊⼰排序序列的正确位置上的⽅法,称为()(A)希尔排序(B)起泡排序(C)插⼊排序(D)选择排序参考答案:C8.排序⽅法中,从未排序序列中挑选元素并将其依次放⼊⼰排序序列(初始为空)的⼀端的⽅法,称为()(A)希尔排序(B)归并排序(C)插⼊排序(D)选择排序参考答案:D9.⽤某种排序⽅法对线性表(25,84,21,47,15,27,68,35,20)进⾏排序时,元素序列的变化情况如下:(1)25,84,21,47,15,27,68,35,20 (2)20,15,21,25,47,27,68,35,84(3)15,20,21,25,35,27,47,68,84 (4)15,20,21,25,27,35,47,68,845则所采⽤的排序⽅法是()。
数据结构习题 3
第6章树6.1选择题1.一棵具有n个结点的完全二叉树的树高度(深度)是()A)⎣log2n⎦+1 B)log2n +1 C)⎣ log2n ⎦D)log2n-12.有关二叉树下列说法正确的是()A)二叉树的度为2 B)一棵二叉树的度可以小于2C)二叉树中至少有一个结点的度为2 D)二叉树中任何一个结点的度都为23.二叉树的第I层上最多含有结点数为()A)2I B)2I-1-1 C)2I-1 D)2I-14.具有10个叶结点的二叉树中有()个度为2的结点A)8 B)9 C)10 D)115.在下述结论中,正确的是()①只有一个结点的二叉树的度为0;②二叉树的度为2;③二叉树的左右子树可任意交换;④深度为K的完全二叉树的结点个数小于或等于深度相同的满二叉树。
A)①②③B)②③④C)②④D)①④6.由3 个结点可以构造出多少种不同的二叉树?()A)2 B)3 C)4 D)57.引入二叉线索树的目的是()A)加快查找结点的前驱或后继的速度B)为了能在二叉树中方便的进行插入与删除C)为了能方便的找到双亲D)使二叉树的遍历结果惟一8.有n个叶子的哈夫曼树的结点总数为()A)不确定B)2n C)2n+1 D)2n-19.一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反,则该二叉树一定满足()A)所有的结点均无左孩子B)所有的结点均无右孩子C)只有一个叶子结点D)是任意一棵二叉树10.一棵完全二叉树上有1001个结点,其中叶子结点的个数是()A)250 B)500 C)505 D)以上答案都不对11.已知一棵二叉树的后序遍历序列为DABEC,中序遍历序列为DEBAC,则它的先序遍历序列为()A)ACBED B)DECAB C)DEABC D)CEDBA12.若一棵二叉树具有10个度为2的结点,5个度为1的结点,则度为0的结点个数是()A)9 B)11 C)15 D)不确定13.利用二叉链表存储树时,根结点的右指针是()A)指向最左孩子B)指向最右孩子C)空D)非空14.设森林F中有三棵树,第一,第二,第三棵树的结点个数分别为M1,M2和M3。
北邮C++数据结构课后习题 习题3参考答案
习题31.填空题(部分答案)(1)栈的进出原则是(___________),队列的进出原则是(___________)。
答案:后进先出(LIFO)先进先出(FIFO)(2)设32位计算机系统中,空栈S存储int型数据,栈顶指针为1024H。
经过操作序列push(1),push(2),pop,push(5),push(7),pop,push(6)之后,栈顶元素为(___________),栈底元素为(___________),栈的高度为(___________),输出序列是(___________),栈顶指针为(___________)H。
答案:6 1 3 2,7 1030(3)两栈共享存储空间,其数组大小为100,数组下标从0开始。
top1和top2分别为栈1和栈2的栈顶元素下标,则栈1为空的条件为(___________),栈2为空的条件为(___________),栈1或栈2满的条件为(___________)。
答案:top1==-1 top2==100 top1+1==top2(4)一个队列的入队顺序是1234,则队列的输出顺序是(___________)。
答案:1234(5)设循环队列数组大小为100,队头指针为front,队尾指针为rear;约定front指向队头元素的前一个位置,该位置永远不存放数据。
则入队操作时,修改rear=(___________),出队操作修改front=(___________),队空的判别条件为(___________),队满的判别条件为(___________)。
若front=20,rear=60,则队列长度为(___________),若front=60,rear=20,则队列长度为(___________)。
答案:(rear+1)%100 (front+1)%100 rear==front (rear+1)%100=front 40 60(6)朴素模式匹配算法中,每个串的起始下标均为1,变量i=100,j=10,分别表示主串和模式串当前比较的字符元素下标,若本次比较两字符不同,则i回溯为(___________),j 回溯为(___________)。
数据结构(C语言版)第三版习题答案
精神成就事业,态度决定一切。
附录习题参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表(Hash)存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下:数据:数据是信息的载体是计算机程序加工和处理的对象包括数值数据和非数值数据数据项:数据项指不可分割的、具有独立意义的最小数据单位数据项有时也称为字段或域数据元素:数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理一个数据元素可由若干个数据项组成数据逻辑结构:数据的逻辑结构就是指数据元素间的关系数据存储结构:数据的物理结构表示数据元素的存储方式或者数据元素的物理关系数据类型:是指变量的取值范围和所能够进行的操作的总和算法:是对特定问题求解步骤的一种描述是指令的有限序列1.4 语句的时间复杂度为:(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3)1.5 参考程序:main(){int XYZ;scanf("%d %d%d"&X&YZ);if (X>=Y)if(X>=Z)if (Y>=Z) { printf("%d %d%d"XYZ);}else{ printf("%d %d%d"XZY);}else{ printf("%d %d%d"ZXY);}else if(Z>=X)if (Y>=Z) { printf("%d %d%d"YZX);}else{ printf("%d%d%d"ZYX);}else{ printf("%d%d%d"YXZ);}}1.6 参考程序:main(){int in;float xa[]p;printf("\nn=");scanf("%f"&n);printf("\nx=");scanf("%f"&x);for(i=0;i<=n;i++)scanf("%f "&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf("%f"p)'}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). O(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路:将顺序表A中的元素输入数组a若数组a中元素个数为n将下标为012...(n-1)/2的元素依次与下标为nn-1...(n-1)/2的元素交换输出数组a的元素参考程序如下:main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<=n-1;i++)scanf("%f "&a[i]);for(i=0;i<=(n-1)/2;i++){ t=a[i]; a[i] =a[n-1-i]; a[n-1-i]=t;} for(i=0;i<=n-1;i++)printf("%f"a[i]);}2.4 算法与程序:main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]);for(i=1;i<n;i++)if(a[i]>a[0]{ t=a[i]; a[i] =a[0]; a[0]=t;}printf("%f"a[0]);for(i=2;i<n;i++)if(a[i]>a[1]{ t=a[i]; a[i] =a[1]; a[1]=t;}printf("%f"a[0]);}2.5 算法与程序:main(){int ijkn;float xta[];printf("\nx=");scanf("%f"&x);printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]); // 输入线性表中的元素for (i=0; i<n; i++) { // 对线性表中的元素递增排序k=i;for (j=i+1; j<n; j++) if (a[j]<a[k]) k=j; if (k<>j) {t=a[i];a[i]=a[k];a[k]=t;}}for(i=0;i<n;i++) // 在线性表中找到合适的位置if(a[i]>x) break;for(k=n-1;k>=i;i--) // 移动线性表中元素然后插入元素xa[k+1]=a[k];a[i]=x;for(i=0;i<=n;i++) // 依次输出线性表中的元素printf("%f"a[i]);}2.6 算法思路:依次扫描A和B的元素比较A、B当前的元素的值将较小值的元素赋给C如此直到一个线性表扫描完毕最后将未扫描完顺序表中的余下部分赋给C即可C的容量要能够容纳A、B两个线性表相加的长度有序表的合并算法:void merge (SeqList ASeqList BSeqList *C){ int ijk;i=0;j=0;k=0;while ( i<=st && j<=st )if (A.data[i]<=B.data[j])C->data[k++]=A.data[i++];elseC->data[k++]=B.data[j++];while (i<=st )C->data[k++]= A.data[i++];while (j<=st )C->data[k++]=B.data[j++];C->last=k-1;}2.7 算法思路:依次将A中的元素和B的元素比较将值相等的元素赋给C如此直到线性表扫描完毕线性表C就是所求递增有序线性表算法:void merge (SeqList ASeqList BSeqList *C){ int ijk;i=0;j=0;k=0;while ( i<=st)while(j<=st )if (A.data[i]=B.data[j])C->data[k++]=A.data[i++];C->last=k-1;}习题3参考答案3.1.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).AB (11). D (12). B (13). D (14). C (15). C (16). D(17). D (18). C (19). C (20). C 3.2.填空题(1) FILOFIFO(2) -13 4 X * + 2 Y * 3 / -(3) stack.topstack.s[stack.top]=x(4) p>llink->rlink=p->rlinkp->rlink->llink=p->rlink(5) (R-F+M)%M(6) top1+1=top2(7) F==R(8) front==rear(9) front==(rear+1)%n(10) N-13.3 答:一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入(称为入栈push)或者读取栈顶元素或者称为"弹出、出栈"(pop)3.4 答:相同点:栈和队列都是特殊的线性表只在端点处进行插入删除操作不同点:栈只在一端(栈顶)进行插入删除操作;队列在一端(top)删除一端(rear)插入3.5 答:可能序列有14种:ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA3.6 答:不能得到435612最先出栈的是4则按321的方式出不可能得到1在2前的序列可以得到135426按如下方式进行push(1)pop()push(2)push(3)pop()push(4)push(5)pop()pop()pop()push(6)pop()3.7 答:stack3.8 非递归:int vonvert (int noint a[]) //将十进制数转换为2进制存放在a[] 并返回位数{int r;SeStack s*p;P=&s;Init_stack(p);while(no){push(pno%2);no/=10;}r=0;while(!empty_stack(p)){pop(pa+r);r++;}return r;}递归算法:void convert(int no){if(no/2>0){Convert(no/2);Printf("%d"no%2);}elseprintf("%d"no);}3.9 参考程序:void view(SeStack s){SeStack *p; //假设栈元素为字符型char c;p=&s;while(!empty_stack(p)){c=pop(p);printf("%c"c);}printf("\n");}3.10 答:char3.11 参考程序:void out(linkqueue q){int e;while(q.rear !=q.front ){dequeue(qe);print(e); //打印}}习题4参考答案4.1 选择题:(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). B (10). D 4.2 填空题:(1)串长相等且对应位置字符相等(2)不含任何元素的串(3)所含字符均是空格所含空格数(4) 10(5) "hello boy"(6) 13(7) 1066(8)模式匹配(9)串中所含不同字符的个数(10) 364.3 StrLength (s)=14StrLength (t)=4SubStr( s87)=" STUDENT"SubStr(t21)="O"StrIndex(s"A")=3StrIndex (st)=0StrRep(s"STUDENT"q)=" I AM A WORKER"4.4 StrRep(s"Y""+");StrRep(s"+*""*Y");4.5 空串:不含任何字符;空格串:所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变;串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串:子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int EQUAl(ST){char *p*q;p=&S;q=&T;while(*p&&*q){if(*p!=*q)return *p-*q;p++;q++;}return *p-*q;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*8=1096(4)1000+(6*7+4)*8=13684.8习题5参考答案5.1 选择(1)C(2)B(3)C(4)B(5)C(6)D(7)C(8)C(9)B(10)C (11)B(12)C(13)C(14)C(15)C(16)B5.2 填空(1)1(2)1036;1040(3)2i(4) 1 ; n ; n-1 ; 2(5)2k-1;2k-1(6)ACDBGJKIHFE(7)p!=NULL(8)Huffman树(9)其第一个孩子; 下一个兄弟(10)先序遍历;中序遍历5.3叶子结点:C、F、G、L、I、M、K;非终端结点:A、B、D、E、J;各结点的度:结点: A B C D E F G L I J K M度: 4 3 0 1 2 0 0 0 0 1 0 0树深:4无序树形态如下:二叉树形态如下:5.5二叉链表如下:三叉链表如下:5.6先序遍历序列:ABDEHICFJG中序遍历序列:DBHEIAFJCG后序遍历序列:DHIEBJFGCA5.7(1) 先序序列和中序序列相同:空树或缺左子树的单支树;(2) 后序序列和中序序列相同:空树或缺右子树的单支树;(3) 先序序列和后序序列相同:空树或只有根结点的二叉树5.8这棵二叉树为:先根遍历序列:ABFGLCDIEJMK后根遍历序列:FGLBCIDMJKEA层次遍历序列:ABCDEFGLIJKM5.10证明:设树中结点总数为n叶子结点数为n0则n=n0 + n1 + ...... + nm (1)再设树中分支数目为B则B=n1 + 2n2 + 3n3 + ...... + m nm (2)因为除根结点外每个结点均对应一个进入它的分支所以有n= B + 1 (3)将(1)和(2)代入(3)得n0 + n1 + ...... + nm = n1 + 2n2 + 3n3 + ...... + m nm + 1 从而可得叶子结点数为:n0 = n2 + 2n3 + ...... + (m-1)nm + 15.11由5.10结论得n0 = (k-1)nk + 1又由 n=n0 + nk得nk= n-n0代入上式得n0 = (k-1)(n-n0)+ 1叶子结点数为:n0 = n (k-1) / k5.12int NodeCount(BiTree T){ //计算结点总数if(T)if (T-> lchild==NULL )&&( T --> rchild==NULL )return 1;elsereturn NodeCount(T-> lchild ) +Node ( T --> rchild )+1; elsereturn 0;}void ExchangeLR(Bitree bt){/* 将bt所指二叉树中所有结点的左、右子树相互交换 */ if (bt && (bt->lchild || bt->rchild)) {bt->lchild<->bt->rchild;Exchange-lr(bt->lchild);Exchange-lr(bt->rchild);}}/* ExchangeLR */5.14int IsFullBitree(Bitree T){/* 是则返回1否则返回0*/Init_Queue(Q); /* 初始化队列*/flag=0;In_Queue(QT); /* 根指针入队列按层次遍历*/while(!Empty_Queue (Q)){Out_Queue(Qp);if(!p) flag=1; /* 若本次出队列的是空指针时则修改flag值为1若以后出队列的指针存在非空则可断定不是完全二叉树 */else if (flag) return 0; /*断定不是完全二叉树 */ else{In_Queue(Qp->lchild);In_Queue(Qp->rchild); /* 不管孩子是否为空都入队列*/}}/* while */return 1; /* 只有从某个孩子指针开始之后所有孩子指针都为空才可断定为完全二叉树*/}/* IsFullBitree */转换的二叉树为:5.16对应的森林分别为:5.17typedef char elemtype;typedef struct{ elemtype data;int parent;} NodeType;(1) 求树中结点双亲的算法:int Parent(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标(根的双亲为-1 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) return t[i].parent; return -2;}/*Parent*/(2) 求树中结点孩子的算法:void Children(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++){if(x==t[i].data)break;/*找到x退出循环*/}/*for*/if(i>=MAXNODE) printf("x不存在\n"); else {flag=0;for(j=0;j<MAXNODE;j++)if(i==t[j].parent){ printf("x的孩子:%c\n"t[j].data);flag=1;}if(flag==0) printf("x无孩子\n");}/*Children*/5.18typedef char elemtype;typedef struct ChildNode{ int childcode;struct ChildNode *nextchild;}typedef struct{ elemtype data;struct ChildNode *firstchild;} NodeType;(1) 求树中结点双亲的算法:int ParentCL(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) {loc=i;/*记下x的下标*/break;}if(i>=MAXNODE) return -2; /* x不存在 *//*搜索x的双亲*/for(i=0;i<MAXNODE;i++)for(p=t[i].firstchild;p!=NULL;p=p->nextchild) if(loc==p->childcode)return i; /*返回x结点的双亲下标*/}/* ParentL */(2) 求树中结点孩子的算法:void ChildrenCL(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++)if(x==t[i].data) /*依次打印x的孩子*/{flag=0; /* x存在 */for(p=t[i].firstchild;p;p=p->nextchild){ printf("x的孩子:%c\n"t[p-> childcode].data);flag=1;}if(flag==0) printf("x无孩子\n");return;}/*if*/printf("x不存在\n");return;}/* ChildrenL */5.19typedef char elemtype;typedef struct TreeNode{ elemtype data;struct TreeNode *firstchild; struct TreeNode *nextsibling; } NodeType;void ChildrenCSL(NodeType *telemtype x){ /* 层次遍历方法 */Init_Queue(Q); /* 初始化队列 */In_Queue(Qt);count=0;while(!Empty_Queue (Q)){Out_Queue(Qp);if(p->data==x){ /*输出x的孩子*/p=p->firstchild;if(!p) printf("无孩子\n");else{ printf("x的第%i个孩子:%c\n"++countp->data);/*输出第一个孩子*/p=p->nextsibling; /*沿右分支*/while(p){printf("x的第%i个孩子:%c\n"++countp->data);p=p-> nextsibling;}}return;}if(p-> firstchild) In_Queue(Qp-> firstchild);if(p-> nextsibling) In_Queue(Qp-> nextsibling);}}/* ChildrenCSL */5.20(1) 哈夫曼树为:(2) 在上述哈夫曼树的每个左分支上标以1右分支上标以0并设这7个字母分别为A、B、C、D、E、F和H如下图所示:则它们的哈夫曼树为分别为:A:1100B:1101C:10D:011E:00F:010H:111习题6参考答案6.1 选择题(1)C (2)A (3)B(4)C(5)B______条边(6)B(7)A(8)A(9)B(10)A(11)A(12)A(13)B(14)A(15)B(16)A(17)C 6.2 填空(1) 4(2) 1对多 ; 多对多(3) n-1 ; n(4) 0_(5)有向图(6) 1(7)一半(8)一半(9)___第i个链表中边表结点数___(10)___第i个链表中边表结点数___(11)深度优先遍历;广度优先遍历(12)O(n2)(13)___无回路6.3(1)邻接矩阵:(2)邻接链表:(3)每个顶点的度:顶点度V1 3V2 3V3 2V4 3V5 36.4(1)邻接链表:(2)逆邻接链表:(3)顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5(1)深度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 (1)广度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量:6.7顶点(1)(2)(3)(4)(5)Low Close Cost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexV10 00 00 00 00 0V21 00 00 00 00 0V31 01 00 00 00 0V43 02 12 10 10 1V5∞ 05 13 22 30 3U{v1} {v1v2} {v1v2v3} {v1 v2 v3 v4} {v1 v2 v3 v4 v5} T {} { (v1 v2) } {(v1 v2) (v1 v3) } {(v1 v2) (v1 v3) (v2 v4) } {(v1 v2) (v1v3)(v2v4)(v4v5) }最小生成树的示意图如下:6.8拓扑排序结果: V3--> V1 --> V4 --> V5 --> V2 --> V66.9(1)建立无向图邻接矩阵算法:提示:参见算法6.1因为无向图的邻接矩阵是对称的所以有for (k=0; k<G ->e; k++) /*输入e条边建立无向图邻接矩阵*/{ scanf("\n%d%d"&i&j);G ->edges[i][j]= G ->edges[j][i]=1;}(2)建立无向网邻接矩阵算法:提示:参见算法6.1初始化邻接矩阵:#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息:不仅要输入边邻接的两个顶点序号还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边建立无向网邻接矩阵*/{ scanf("\n%d%d%d"&i&j&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示:参见算法6.16.10(1)建立无向图邻接链表算法:typedef VertexType char;int Create_NgAdjList(ALGraph *G){ /* 输入无向图的顶点数、边数、顶点信息和边的信息建立邻接表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*边数不能为负 */G->e=e;for(m=0;m< G->n ;m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e; m++){scanf("\n%d%d"&i&j); /* 输入一对邻接顶点序号*/if((i<0 || j<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/ p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/ p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;} /* for*/return 0; /*成功*/}//Create_NgAdjList(2)建立有向图逆邻接链表算法:typedef VertexType char;int Create_AdjList(ALGraph *G){ /* 输入有向图的顶点数、边数、顶点信息和边的信息建立逆邻接链表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*弧数不能为负 */G->e=e;for(m=0;m< G->n; m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e ; m++){scanf("\n%d%d"&t&h); /* 输入弧尾和弧头序号*/if((t<0 || h<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第h+1个链表中插入一个边表结点*/ p->adjvex=t;p->next= G-> adjlist [h].firstedge;G-> adjlist [h].firstedge=p;} /* for*/return 0; /*成功*/}//Create_AdjList6.11void Create_AdjM(ALGraph *G1MGraph *G2){ /*通过无向图的邻接链表G1生成无向图的邻接矩阵G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G2->n;i++) /* 置G2每个元素为0 */for(j=0;j<G2->n;j++) G2->edges[i][j]= 0;for(m=0;m< G1->n;m++)G2->vexs[m]=G1->adjlist[m].vertex; /*复制顶点信息*/num=(G1->n/2==0?G1->n/2:G1->n/2+1); /*只要搜索前n/2个单链表即可*/for(m=0;m< num;m++){ p=G1->adjlist[m].firstedge;while(p){ /* 无向图的存储具有对称性*/G2->edges[m][ p->adjvex ]= G2->edges[p->adjvex ] [m] =1;p==p->next;}}/* for */}/*Create_AdjM */void Create_AdjL(ALGraph *G1MGraph *G2){ /*通过无向图的邻接矩阵G1生成无向图的邻接链表G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G1->n;i++) /* 建立每个单链表 */{ G2->vexs[i]=G1->adjlist[i].vertex;G2->adjlist[i].firstedge=NULL;for(j=i; j<G1->n; j++) /*对称矩阵只要搜索主对角以上的元素即可*/{ if(G1->edges[i][j]== 1){ p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;}/*if*/}/* for*/}/* for*/}/* Create_AdjL */6.13(1) 邻接矩阵中1的个数的一半;(2) 若位于[i-1j-1]或[j-1i-1]位置的元素值等于1则有边相连否则没有(3) 顶点i的度等于第i-1行中或第i-1列中1的个数6.14(1) 邻接链表中边表结点的个数的一半;(2) 若第i-1(或j-1)个单链表中存在adjvex域值等于j-1(或i-1)的边表结点则有边相连否则没有(3) 顶点i的度等于第i-1个单链表中边表结点的个数提示:参见算法6.2 和6.3习题 7参考答案7.1 选择题(1)C (2)C (3) C (4)B (5) A (6)A (7) D (8)B (9)D (10) B(11)B (12)A (13)C (14)C (15)A (16)D (17)C (18)BC (19)B (20)A7.2 填空题(1) O(n)O(log2n)(2) 12485log2(n+1)-1(3)小于大于(4)增序序列(5)m-1(6) 70; 342055(7) n/m(8)开放地址法链地址法(9)产生冲突的可能性就越大产生冲突的可能性就越小(10)关键码直接(11)②①⑦(12) 1616821(13)直接定址法数字分析法平方取中法折叠法除留余数法随机数法(14)开放地址法再哈希法链地址法建立一个公共溢出区(15)装满程度(16)索引快(17)哈希函数装填因子(18)一个结点(19)中序(20)等于7.3 一棵二叉排序树(又称二叉查找树)或者是一棵空树或者是一棵同时满足下列条件的二叉树:(1)若它的左子树不空则左子树上所有结点的键值均小于它根结点键值(2)若它的右子树不空则右子树上所有结点的键值均大于它根结点键值(3)它的左、右子树也分别为二叉排序树7.4 对地址单元d=H(K)如发生冲突以d为中心在左右两边交替进行探测按照二次探测法键值K的散列地址序列为:do=H(K)d1=(d0+12)mod md2=(d0-12)mod md3=(d0+22)mod md4=(d0-12)mod m......7.5 衡量算法的标准有很多时间复杂度只是其中之一尽管有些算法时间性能很好但是其他方面可能就存在着不足比如散列查找的时间性能很优越但是需要关注如何合理地构造散列函数问题而且总存在着冲突等现象为了解决冲突还得采用其他方法二分查找也是有代价的因为事先必须对整个查找区间进行排序而排序也是费时的所以常应用于频繁查找的场合对于顺序查找尽管效率不高但却比较简单常用于查找范围较小或偶而进行查找的情况7.6此法要求设立多个散列函数Hii=1...k当给定值K与闭散列表中的某个键值是相对于某个散列函数Hi的同义词因而发生冲突时继续计算该给定值K在下一个散列函数Hi+1下的散列地址直到不再产生冲突为止7.7散列表由两个一维数组组成一个称为基本表另一个称为溢出表插入首先在基本表上进行;假如发生冲突则将同义词存人溢出表7.8 结点个数为n时高度最小的树的高度为1有两层它有n-1个叶结点1个分支结点;高度最大的树的高度为n-l有n层它有1个叶结点n-1个分支结点7.9 设顺序查找以h为表头指针的有序链表若查找成功则返回结点指针p查找失败则返回null值pointer sqesrearch(pointer hint xpointerp){p=null;while(h)if(x>h->key)h=h->link;else{if(x==h->key)p=h;return(p);}}虽然链表中的结点是按从小到大的顺序排列的但是其存储结构为单链表查找结点时只能从头指针开始逐步进行搜索故不能用折半(二分)查找7.10 分析:对二叉排序树来讲其中根遍历序列为一个递增有序序列因此对给定的二叉树进行中根遍历如果始终能保证前一个值比后一个值小则说明该二叉树是二叉排序树int bsbtr (bitreptr T) /*predt记录当前结点前趋值初值为-∞*/{ if (T==NULL) return(1);else{b1=bsbtr(T->lchild);/*判断左子树*/if (!b1|| (predt>=T->data)) return(0);*当前结点和前趋比较*/ predt=T->data;/*修改当前结点的前趋值*/return(bsbtr(T->rchild));/*判断右子树并返回最终结果*/}}7.11 (1)使用线性探查再散列法来构造散列表如表下所示散列表───────────────────────────────地址 0 1 2 3 4 5 6 7 8 9 10───────────────────────────────数据 33 1 13 12 34 38 27 22───────────────────────────────(2)使用链地址法来构造散列表如下图(3)装填因子a=8/11使用线性探查再散列法查找成功所需的平均查找次数为Snl=0.5(1+1/(1-a))=0.5*(1+1/(1-8/11))=7/3使用线性探查再散列法查找不成功所需的平均查找次数为:Unl=0.5(1+1/(1-a)2)=0.5*(1+1/(1-8/11)2)=65/9 使用链地址法查找成功所需的平均查找次数为:Snc=l+a/2=1+8/22=15/11使用链地址法查找不成功所需的平均查找次数为: 'Unl=a+e-a=8/1l+e-8/117.12 分析:在等查区间的上、下界处设两个指针由此计算出中间元素的序号当中间元素大于给定值X时接下来到其低端区间去查找;当中间元素小于给定值X时接下来到其高端区间去查找;当中间元素等于给定值X时表示查找成功输出其序号Int binlist(sqtable Aint stkeytype X) /*t、s分别为查找区间的上、下界*/{ if(s<t) return(0);/*查找失败*/else{ mid=(S+t)/2;switCh(mid){case x<A.item[midJ.key: return(binlist(Asmid-lX));/*在低端区间上递归*/case x==A.item[mid].key: return(mid);/+查找成功*/ case x>A.item[mid].key: return(amid+ltX));/*在高端区间上递归*/}}}int sqsearch0 (sqtable Akeytype X) /*数组有元素n个*/{ i=l;A.item[n+1].key=X;/t设置哨兵*/while (A.item[n+1].key!=X) i++;return (i% (n/1));/*找不到返回0找到返回其下标*/}查找成功平均查找长度为:(1+2+3+...+n)/n:(1+n)/2查找不成功平均查找长度为:n+17.14散列函数:H(key)=100+(key个位数+key十位数) mod l0;形成的散列表:100 101 102 103 104 105 106 107 108 10998 75 63 46 49 79 61 53 17查找成功时的平均长度为:(1+2+1+1+5+1+1+5+5+3)/10=2.5次由于长度为10的哈希表已满因此在插人第11个记录时所需作的比较次数的期望值为10查找不成功时的平均长度为10习题 8参考答案8.1 选择题(1)B (2)A (3)D (4)C (5)B (6)A (7)B (8)C (9)A (10)C(11)D (12)C (13) C (14)D (15)C (16)B (17) D (18)C (19)B (20)D8.2填空题(1)快速归并(2) O(log2n)O(nlog2n)(3)归并(4)向上根结点(5) 1918162030(6)(7)4913275076386597(8)88(9)插入选择(每次选择最大的)(10)快速归并(11)O(1)O(nlog2n)(12)稳定(13)3(14)(15205040)(15)O(log2n)(16)O(n2)(17)冒泡排序快速排序(18)完全二叉树n/2(19)稳定不稳定(20)24(2015)8.3. 假定给定含有n个记录的文件(r1f2...rn)其相应的关键字为(k1k2...kn)则排序就是确定文件的一个序列rrr2...rn使得k1'≤k2'≤...≤kn'从而使得文件中n个记录按其对应关键字有序排列如果整个排序过程在内存中进行则排序叫内部排序假设在待排序的文件中存在两个或两个以上的记录具有相同的关键字若采用某种排序方法后使得这些具有相同关键字的记录在排序前后相对次序依然保持不变则认为该排序方法是稳定的否则就认为排序方法是不稳定的8.4.稳定的有:直接插入排序、二分法插入排序、起泡排序、归并排序和直接选择排序8.5.初始记录序列按关键字有序或基本有序时比较次数为最多8.6.设5个元素分别用abcde表示取a与b、c与d进行比较若a>bc>d(也可能是a<bc<d此时情况类似)显然此时进行了两次比较取b与d再比较若b>d则a>b>d若b<d则有c>d>b此时已进行了3次比较要使排序比较最多7次可把另外两个元素按折半检索排序插入到上面所得的有序序列中此时共需要4次比较从而可得算法共只需7次比较8.7.题目中所说的几种排序方法中其排序速度都很快但快速排序、归并排序、基数排序和Shell排序都是在排序结束后才能确定数据元素的全部序列而排序过程中无法知道部分连续位置上的最终元素而堆排序则是每次输出一个堆顶元素(即最大或最少值的元素)然后对堆进行再调整保证堆顶元素总是当前剩下元素的最大或最小的从而可知欲在一个大量数据的文件中如含有15000个元素的记录文件中选取前10个最大的元素可采用堆排序进行8.8.二分法排序8.9.void insertsort(seqlist r)  ;{ //对顺序表中记录R[0一N-1)按递增序进行插入排序&NBSP;int ij;  ;for(i=n-2;i>=0; i--) //在有序区中依次插入r[n-2]..r[0]  ;if(r[i].key>r[i+1].key) //若不是这样则r[i]原位不动 ;{  ;r[n]=r[i];j=i+l;//r[n]是哨兵 ;do{ //从左向右在有序区中查找插入位置 ;r[j-1]= r[j];//将关键字小于r[i].key的记录向右移 ;j++;  ;}whle(r[j].key r[j-1]=r[n];//将引i)插入到正确位置上 ;}//endif ;}//insertsort.  ;8.10.建立初始堆:[937 694 863 265 438 751 742129075 3011]&NBSP;&NBSP;第一次排序重建堆:[863 694 751 765 438 301 742 129 075]9378.11.在排序过程中每次比较会有两种情况出现若整个排序过程至少需作t次比较则显然会有2^t个情况由于n个结点总共有n!种不同的排列因而必须有n!种不同的比较路径于是: 2t≥n!即t≥log2n!因为log2nl=nlog2n-n/ln2+log2n/2+O(1)故有log2n!≈nlog2n从而t≧nlog2n得证8.12.依据堆定义可知:序列(1)、(2)、(4)是堆(3)不是堆从而可对其调整使之为如下的大根堆(1009580604095821020)8.13.第一趟:[265 301] [129 751] [863 937] [694 742] [076 438]&NBSP; &NBSP;第二趟:[129 265 301 751] [694 742 863 937] [076 438]&NBSP;&NBSP;第三趟:[129 265 301 694 742 751 863 937] [076 438]&NBSP;&NBSP;第四趟:[076 129 265 301 438 694 742 751 863 937]&NBSP;8.14.(1)归并排序:(1829) (2547) (1258) (1051)(18252947) (10125158)(1012182529475158)(2)快速排序:(1018251229585147)(1018251229475158)(1012182529475158)(3)堆排序:初始堆(大顶堆):(58 47512918122510)第一次调整:(51 472529181210)(58)第二次调整:(47 2925101812)(5158)第三次调整:(29 18251012)(475158)第四次调整:(25 181210)(29475158)第五次调整:(18 1012)(2529475158)第六次调整:(12 10) (182529475158)第七次调整:(10 12182529475158)8.15.(1)直接插入排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 151=2 40 83 [63 13 84 35 96 57 39 79 61 15] 1=3 40 63 83 [13 84 35 96 57 39 79 61 15] 1=4 13 40 63 83 [84 3 5 96 57 39 79 61 15] I=5 13 40 63 83 84 [35 96 57 39 79 61 15] I=6 13 35 40 63 83 84 [96 57 39 79 61 15] 1=7 13 35 40 63 83 84 96 [57 39 79 61 15] 1=8 13 35 40 57 63 83 84 96 [ 39 79 61 15] 1=9 13 35 39 40 57 63 83 84 96 [79 61 15] I=10 13 35 39 40 57 63 79 83 84 96 [61 15] I=11 13 35 39 40 57 61 63 79 83 84 96 [15] 1=12 13 15 35 39 40 57 61 63 79 83 84 96 (2)直接选择排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 15i=1 13 [ 40 63 83 84 35 96 57 39 79 61 15] i=2 13 15 [63 83 84 35 96 57 39 79 61 40] i=3 13 15 35 [83 84 63 96 57 39 79 61 40] i=4 13 15 35 39 [84 63 96 57 83 79 61 40] i=5 13 15 35 39 40 [63 96 57 83 79 61 84] i=6 13 15 35 39 40 57 [96 63 83 79 61 84] i=7 13 15 35 39 40 57 61 [63 83 79 96 84] i=8 13 15 35 39 40 57 61 63 [83 79 96 84] i=9 13 15 35 39 40 57 61 63 79 183 96 84] i=10 13 15 35 39 40 57 61 63 79 83 [96 84] i=11 13 15 35 39 40 57 61 63 79 83 84 [96] (3)快速排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [15 40 63 13 61 35 79 57 39] 83 [96 84] 第二趟排序后 [13] 15 [63 40 61 35 79 57 39] 83 84 [96] 第三趟排序后 13 15 [39 40 61 35 57] 63 [79] 83 84 96 第四趟排序后 13 15 [35] 39 [61 40 57] 63 79 83 84 96第五趟排序后 13 15 35 39 [57 40] 61 63 79 83 84 96 第六趟排序后 13 15 35 39 40 [57] 61 63 79 83 84 96 第七趟排序后 13 15 35 39 40 57 61 63 79 83 84 96 (4)堆排序关键字 83 40 63 13 84 35 96 57 39 79 61 15排序成功的序列 96 84 83 79 63 61 57 40 39 35 15 13(5)归并排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [40 83] [13 63] [3584] [57 96] [39 79] [15 61]第二趟排序后 [13 40 63 83] [35 57 84 96] [15 39 61 79] 第三趟排序后 [13 35 40 57 63 83 84 96]] [15 39 61 79] 第四趟排序后 13 15 35 39 40 57 61 63 79 83 84 96。
数据结构习题3(数组)
一、选择题1. 将一个A[1..100,1..100]的三对角矩阵,按行优先存入一维数组B[1‥298]中,A中元素A6665(即该元素下标i=66,j=65),在B数组中的位置K为()。
供选择的答案:A. 198B. 195C. 1972. 二维数组A的元素都是6个字符组成的串,行下标i的范围从0到8,列下标j的范圈从1到10。
从供选择的答案中选出应填入下列关于数组存储叙述中()内的正确答案。
(1)存放A至少需要(E)个字节;(2)A的第8列和第5行共占(B)个字节;(3)若A按行存放,元素A[8,5]的起始地址与A按列存放时的元素( B )的起始地址一致。
供选择的答案:(1)A. 90 B. 180 C. 240 D. 270 E. 540(2)A. 108 B. 114 C. 54 D. 60 E. 150(3)A. A[8,5] B. A[3,10] C. A[5,8] D. A[0,9]3. 设A是n*n的对称矩阵,将A的对角线及对角线上方的元素以列为主的次序存放在一维数组B[1..n(n+1)/2]中,对上述任一元素aij(1≤i,j≤n,且i≤j)在B中的位置为( A )。
A. i(i-l)/2+jB. j(j-l)/2+iC. j(j-l)/2+i-1D. i(i-l)/2+j-14. A[N,N]是对称矩阵,将下面三角(包括对角线)以行序存储到一维数组T[N(N+1)/2]中,则对任一上三角元素a[i][j]对应T[k]的下标k是(B)。
A. i(i-1)/2+jB. j(j-1)/2+iC. i(j-i)/2+1D. j(i-1)/2+15. 设二维数组A[1.. m,1..n](即m行n列)按行存储在数组B[1.. m*n]中,则二维数组元素A[i,j]在一维数组B中的下标为( A)。
A.(i-1)*n+jB.(i-1)*n+j-1C. i*(j-1)D. j*m+i-16.有一个二维数组A,行下标的范围是0到8,列下标的范围是1到5,每个数组元素用相邻的4个字节存储。
数据结构第三章习题
数据结构第三章习题3.1 单项选择题2.一个栈的入栈序列a, b, c, d, e, 则栈的不可能的输出序列是。
A. edcbaB. DecbaC. DceabD. abcde3. 若已知一个栈的入栈序列是1,2,3,………..n, 其输出序列为p1, p2, p3,……,pn, 若p1=n, 则pi为。
A.i.B. n=IC. n- i+1D.不确定4.栈结构通常采用的两种存储结构是。
A. 顺序存储结构和链表存储结构B. 散链方式和索引方式C.链表存储结构和数组D. 线性存储结构和非线性存储结构5.判定一个栈ST(最多元素为m0)为空的条件是。
A. ST->top<>0B. ST->top=0C.ST->top<>m0D.ST->top=m06.判定一个栈ST(最多元素为m0)为栈满的条件是。
A. ST->top!=0B.ST->top==0C.ST->top!=m0D.ST->top==m07.栈的特点是,队列的特点是。
A先进先出 B. 先进后出8. 一个队列的入栈序列是1,2,3,4,则队列的输出序列是。
A. 4,3,2,1B. 1,2,3,4C. 1,4,3,2D. 3,2,4,19. 判定一个队列QU(最多元素为m0)为空的条件是。
A.QU->rear- QU->front==m0B.QU->rear- QU->front-1==m0C.QU->front== QU->rearD. QU->front== QU->rear+110.判定一个队列QU(最多元素为m0)为满队列的条件是。
A.QU->rear- QU->front==m0B.QU->rear- QU->front-1==m0C.QU->front== QU->rearD.QU->front== QU->rear+111. 判定一个循环队列QU(最多元素为m0)为空的条件是。
数据结构复习题3
数据结构练习题第一章绪论一.选择题1、在数据结构的讨论中把数据结构从逻辑上分为()。
A.内部结构与外部结构B.静态结构与动态结构C.线性结构与非线性结构D.紧凑结构与非紧凑结构2、采用线性链表表示一个向量时,要求占用的存储空间地址()。
A: 必须是连续的 B 部分地址必须是连续的C: 一定是不连续的C: 可连续可不连续3、采用顺序搜索方法查找长度为n的顺序表时,搜索成功的平均搜索长度为()。
A: n B: n/2 C: (n-1)/2 D: (n+1)/24、在一个单链表中,若q结点是p结点的前驱结点,若在q与p之间插入结点s,则执行()。
A: s→next = p→next;p→next = s; B: p→next= s; s→next = q;C: p→next = s→next;s→next = p;D: q→next= s;s→next= p;8.下面程序段的时间复杂度为____________。
for(int i=0; i<m; i++)for(int j=0; j<n; j++)a[i][j]=i*j;A、 O(m2)B、 O(n2)C、 O(m*n)D、 O(m+n)9.执行下面程序段时,执行S语句的次数为____________。
for(int i=1; i<=n; i++)for(int j=1; j<=i; j++)S;A、 n2B、 n2/2C、 n(n+1)D、 n(n+1)/2二.填空题1.通常,评价一个算法有正确性、健壮性、_________、时间复杂度、空间复杂度五个方面。
2.在数据结构中,数据的逻辑结构有线性结构、图结构、________________、_______________四种,物理实现上有顺序结构、索引结构、___________、_____________四种。
第三章线性表一.选择题1.在一个单链表HL中,若要向q所指结点之后插入一个指针p指向的结点,则执行.A. HL=p; p->next=HLB. P->next=HL; HL=pC. P->next=q->next; q->next=pD. P->next=q->next; q=p->next2.在一个长度为n的顺序存储线性表中,向第i个元素(1≤i≤n+1)之前插入一个新元素时,需要从后向前依次后移个元素。
《数据结构》习题汇编03 第三章 栈和队列 试题上课讲义
《数据结构》习题汇编03第三章栈和队列试题第三章栈和队列试题一、单项选择题1.栈的插入和删除操作在()进行。
A. 栈顶B. 栈底C. 任意位置D. 指定位置2.当利用大小为n的数组顺序存储一个栈时,假定用top==n表示栈空,则向这个栈插入一个元素时,首先应执行()语句修改top指针。
A. top++;B. top--;C. top = 0;D.top;3.若让元素1,2,3依次进栈,则出栈次序不可能出现()种情况。
A. 3, 2, 1B. 2, 1, 3C. 3, 1, 2D.1, 3, 24.在一个顺序存储的循环队列中,队头指针指向队头元素的()位置。
A. 前一个B. 后一个C. 当前D.后面5.当利用大小为n的数组顺序存储一个队列时,该队列的最大长度为()。
A. n-2B. n-1C. nD. n+16.从一个顺序存储的循环队列中删除一个元素时,需要()。
A. 队头指针加一B. 队头指针减一C. 取出队头指针所指的元素D. 取出队尾指针所指的元素7.假定一个顺序存储的循环队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。
A. front+1 == rearB. rear+1 == frontC. front == 0D. front == rear8.假定一个链式队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。
A. front == rearB. front != NULLC. rear != NULLD. front == NULL9.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。
若想在链式栈的栈顶插入一个由指针s所指的结点,则应执行操作()。
A. top->link = s;B.s->link = top->link;top->link = s;C. s->link = top; top = s;D. s->link = top; top = top->link;10.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
从上图可以看出,查找失败的最少比较次数为 3,最多比较次数为 4 次,故而选择 B答案。要特别注意,有的书把失败的比较也算作一次 比较,这里我们不算一次比较。
第五部分
查找
考点四 二叉排序树
本考点主要考查:
二叉排序树的概念和构造方法
第五部分
查找
考点四 二叉排序树
1. 若构造一棵具有 n 个结点的二叉排序树,最坏的情况下其深度不超 过 ( B ) A. n/2 B. n C. (n+1)/2 D. n+1 【解析】 最坏的情况下, 二叉排序树为单支树, 比如构造一棵 {1,2,3,4,5,…,n}的二叉树,则得到的二叉排序树如下图所示。
D. ③
【解析】对于 m 阶 B 树,除了根结点至少要有两棵子树之外,其他非 叶子结点至少有⌈m/2⌉棵子树,故而①错误。树中,每个结点至多有 m-1 个关键字,而且所有叶子都在同一层上,故而②③显然正确。但 是,插入一个关键字使得 B 树结点分裂,并不一定会引起树长高一层 ,如第 2 题中插入结点 70, B-树的前后高度都是 2,故而④错误。
第五部分
查找
考点七 哈希表
1. 以下说法错误的是 ( B ) A. 散列法存储的思想是由关键字值决定数据的存储地址 B. 散列表的结点中只包含数据元素自身的信息,不包含指针。 C. 负载因子是散列表的一个重要参数,它反映了散列表的饱满程度。 D. 散列表的查找效率主要取决于散列表构造时选取的散列函数和处理 冲突的方法。
数据结构
习 题 三
第五部分
查找
考点一 查找的基本概念
本部分考查查找的基本概念。
第五部分
查找
考点一 查找的基本概念
1. 要进行线性查找,则线性表 (1) D ;要进行二分查找,则线性表 (2) E ;要进行散列查找,则线性表 (3) C 。某顺序存储的表格,其 中有 90000 个元素,已按关键项的值的上升顺序排列。现假定对各个 元素进行查找的概率是相同的,并且各个元素的关键项的值皆不相同 。当用顺序查找法查找时,平均比较次数约为 (4) C ,最大比较次数 为 (5) D 。
第五部分
查找
考点六 B 树及其基本操作、 B+树的基本概念
1. 设输入序列为 20, 45, 30, 89, 70, 38, 62, 19 依次插入到一棵 2-3 树 中(初始状态为空),该 B-树为( B )。再删除 38,该 B-树为( F )。
第五部分
查找
考点六 B 树及其基本操作、 B+树的基本概念
对上表进行折半查找元素 82,首先,⌊low+ high)/2⌋ = ⌊(1 + 13)/2⌋ = 7 ,显然 A[7]=45<82,故而,在 A[8]~A[13]中再进行折半查找。 此时, low=7+1=8,high=13,⌊(low + high)/2⌋ = ⌊(8 + 13)/2⌋ = 10, 显然 A[10]=77<82,继续在 A[11]~A[13]中查找。 此时, low=10+1=11, high=13,因为⌊(low+ high)/2⌋=⌊(11 + 13)/2⌋ = 12, A[12]=95>82, 故而在 A[11]查找。因为 high=mid-1=12-1=11=low, A[low]=A[high]=82 ,查找成功。
【解析】构建 B-树的过程如图所示。
第五部分
查找
考点六 B 树及其基本操作、 B+树的基本概念
B-树的删除操作不同于插入操作,其步骤如下: ① 首先查找待删除关键字所在结点,并且要求删除之后,结点中的关键字个 数不小于⌈m/2⌉ − 1; ② 否则,要从其左(或右)兄弟结点“借”关键字; ③ 若其左右兄弟都没有关键字可以借(结点中只有最少量的关键字),则必 须进行结点的合并。 下面我们再来看看删除结点 38 之后, B-树的变化情况。如图 6.5 所示。待删 除关键字38 所在结点向其左兄弟接一个关键字,于是把父结点的 30“ 拉下 来”,把兄弟结点里面最靠近自己的那个关键字往父结点“ 拉上去”,最后 得到下图(2)所示的B-树
第六部分
排序
考点二 插入排序
本考点主要考查折半插入排序和直接插入排序。请同学们 注意插入排序的复杂度、平均移动元素次数,并围绕这两 个点展开复习。
第六部分
排序
考点二 插入排序
1. n 个关键码排序,如果选用直接插入排序方法,则元素的移动次数 在最坏情况下可以达到 ( B) A. n2/2 B. n(n-1)/2 C. n/2 D. (n-1)/2
第五部分
查找
考点二 顺序查找法
顺序查找法通常考查查找一个元素的平均查找长度。
第五部分
查找
考点二 顺序查找法
1. 对于静态表的顺序查找法,若在表头设置岗哨,则正确的查找方 式为 ( C ) A. 从第 0 个元素往后查找该数据元素 B. 从第 1 个元素往后查找该数据元素 C. 从第 n 个元素往开始前查找该数据元素 D. 与查找顺序无关
第六部分
排序
考点一 排序的基本概念
本考点考查排序的基本概念。
第六部分
排序
考点一 排序的基本概念
1. 一个排序算法时间复杂度大小( C ) 有关。 A. 不与所需移动记录的数目 C. 与所需比较关键字的次数 B. 与该算法的稳定性 D. 与所需辅助存储空间的大小
【解析】本题考查影响排序算法时间复杂度的因素。 内部排序算法种 类繁多,但就其排序所遵循的原则而言, 大致可分为五大类: 插入排 序、交换排序、选择排序、归并排序和基数排序。算法性能主要从时 间复杂度、空间复杂度和稳定性三个方面来比较。一个算法的时间复 杂度,与所需要比较的关键字次数、需要移动的记录数量都有关,但 是与算法是否稳定没有关系,与所需要的辅助空间也没有关系。
(1)~(3): A. 必须以顺序方式存储 B. 必须以链表方式存储 C. 必须以散列方式存储 D. 既可以以顺序方式,也可以以链表方式存储 E. 必须以顺序方式存储且数据元素已按值递增或递减的次序排好 F. 必须以链表方式存储且数据元素已按值递增或递减的次序排好 (4)~(5): A. 25000 B. 30000 C. 45000 D. 90000
第五部分
查找
考点七 哈希表
本考点主要命题有以下几种形式: 1、什么是哈希表的特点?影响哈希表查 找效率的因素有哪些?有哪些解决冲突的方法? 2、怎么构建哈希表、怎么样利用冲突解决 方案(如链地址法、二次探测再散列等)来解决冲突。这 部分需要考生手工画图; 3、计算哈希表的在查找成功和查找失败的情况下平均查找 长度(或查找某一个元素的比较次数)。
【解析】二次探测再散列法,简单地理解,就是先探测 H(key)=key mod 11 ,若成功,则得到 key 的地址,否则依次探测 H( key) =( key±i*i ) mod 14,直到探测到 key 的地址为止。【注意,处理冲突为(mod 表长)】 因为 H( 49) =49 mod 11=5,与 38 的地址发生冲突。再计算 H1 = (5 + 12) mod14 = 6 可知依然发生了冲突。再接着计算 H1 = (5 − 12) mod 14 = 4 可知依然发生了冲突。再接着计算 H2 = (5 + 22) mod 14 = 9 因为没有关键字存放在下标为 9 的位置,所以 49 可以放在下标为 9 的位置。
由上图可以看出,最坏的情况下,每插入一个结点,都在该二叉排序 树的尾部插入,该二叉排序树插入结点的复杂度类似于在链表的表尾 增加一个结点,该二叉排序树的深度为 n。
第五部分
查找
考点五 平衡二叉树
本考点主要考查:
平衡二叉树的概念和构造方法
第五部分
查找
考点五 平衡二叉树
1. 由元素序列( 27, 16, 75, 38, 51)构造平衡二叉树,则首次 出现的最小不平衡子树的根(即离插入结点最近且平衡因子的绝对值 为 2 的结点)为 ( D ) A. 27 B. 38 C. 51 D. 75
第五部分
查找
(B )
考点六 B 树及其基本操作、 B+树的基本概念
2. 下面关于 m 阶 B 树说法正确的是 ① 每个结点至少有两棵非空子树; ② 树中每个结点至多有 m−1 个关键字; ③ 所有叶子在同一层上; ④ 当插入一个数据项引起 B 树结点分裂后,树长高一层。 A. ①②③ B. ②③ C. ②③④
【解析】 由元素序列( 27, 16, 75, 38, 51)构造平衡二叉树, 首次出 现的最小不平衡子树的根(即离插入结点最近且平衡因子的绝对值为 2 的结点) 为第一次需要旋转的部分,我们来看看构造平衡二叉树的过程(如下图):
如上图所示,当插入结点 51 之后,有 27 和 75 两个结点失去平衡,但是首 次出现的最小不平衡子树应该是离插入结点 51 最近的且平衡因子的绝对值为 2 的结点 75,而不是27。
【解析】对静态表的顺序查找,通常在表头或者表尾设置岗哨,道理 其实都是一样的。本题中,若在表头设置岗哨,则应该从表尾开始向 表头方向查找,即从第 n 个元素开始向前查找数据元素,若查找成功 ,则返回该元素的位置。若返回的结果是 0,则表示读到了岗哨,查 找失败。
第五部分
查找
考点三 折半查找法
折半查找算法是本章的重点内容,也是数据结构的 重点考点,主要考查: 1、折半查找的条件; 2、折半查找条件下的关键字比较次数、平均时间复 杂度; 3、折半查找树的建立。
【解析】散列表解决冲突的办法有多种,比如线性探测法、 平方探测 法、 再散列法等开放定址法(即:可存放新表项的空闲地址既向其同 义词表项开放,也向其非同义词表项开放)。当然,还有拉链法,拉 链法的散列表中的结点除了包含元素自身信息,还会有其同义词的指 针,而散列地址为 i 的同义词链表的头指针存放在散列表的第 i 个单 元中。