数据结构模拟题答案.docx
《数据结构模拟题答案.docx》由会员分享，可在线阅读，更多相关《数据结构模拟题答案.docx（36页珍藏版）》请在冰豆网上搜索。
数据结构模拟题答案
数据结构模拟试题
（一）参考答案
一、单项选择题
l．C2．B3．A4．B5．C6．B7．A
8．C9．D10．A11．A12．C13．A14．D
15．C16．A17．B18．D19．A20．C
二、填空题
1．逻辑结构存储结构2．前趋节点后继节点3．上溢4．B
5．串变量串常量6．（a）（（（b））,j,（（（d））））7．中序序列8．2k－1
9．n10．0（n＋e）11．不变12．O（log2n）
13．散列组织链组织14．左15．冲突
三、名词解释
l．循环链表：
是一种首位相连的链表。
单循环链表形成一个next环，而双循环链表形成next链环和prior链环。
2．队列：
是一种运算受限的单链表。
它只允许在表的一端进行插入，而在另一端进行删除。
允许删除的一端称为队头，允许插入的一端称为队尾。
3．三角矩阵：
主对角钱以上或以下的元素（不包括对角钱）均为常数的矩阵。
4．有序树：
树中节点的各子树看成是从左至右依次有序且不能交换。
5．生成树：
连通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树。
四、简答题
1．线形结构的逻辑特征是除开始节点和终端节点外，其余每个节点只有一个直接前趋和一个直接后继，即节点间存在一对一的关系；而非线形结构的逻辑特征是一个节点可以有多个直接前趋和直接后继，即节点间存在多对多的关系。
2．本题利用栈的“后进先出”特点，有如下几种情况：
A进A出B进B出C进C出产生输出序列ABC
A进A出B进C进C出B出产生输出序列ACB
A进B进B出A出C进C出产生颇出序列BAC
A进B进B出C进C出A出产生输出序列BCA
A进B进C进C出B出A出产生输出序列CBA
不可能产生输出序列CAB。
3．程序运行前被分配以一个给定大小的存储空间的顺序串称为静态顺序串。
在程序运行过程中，动态分配空间可以链表形式存在的顺序串称为动态顺序串，静态串存在于内存一片连续的数据区中，动态串存在与内存堆中。
4．前序排序：
ABDEHCFI
中根排序：
DBHEACIF
后根排序：
DHEBIFCA
5．邻接矩阵如下：
邻接表如下：
五、应用题
inttwochild（bttree）
{
intnum1，num2
if（tree＝＝null）return（0）；
else
if（tree->left!
=NULL&&tree->right!
=null）return
（1）；
else
{
num1=twochild（tree—>left）;
num2=twochild（tree－＞right）;
return（num1+num2）;
}
}
2.设静态链表是用一维结构数组实现的：
structelement{
intdata;
intcurs;
}
statiin（elementr[]）
{
intI,P;
element*p;
r[0].curs=0;
r[0].dsta=0;
for（I=l;I<=n;I++）
{p=r[0].curs,
Pre=0;
scanf（"%d",r[I].data）;
while（（r[I].data>r[p].data）&&（r[pre].curs<>0））
{
Pre=p;p=r[p].curs;
}
r[I].curs=p;
r[pre].curs=I;
}
}
数据结构模拟试题
（二）参考答案
一、单项选择题
1．B2．A3．B4．C5．A
6．A7．A8．C9．C10．B
11．B12.D13．B14．C15．C
16．C17．B18．B19．C20．A
二、填空题
1．存储空间规模n
2．单链表
3．O（l）
4．下溢
5．头尾指针相等
6．顺序串链串
7．i*（i-1）/2+j
8．行数
9．最小
10．68
11．不是
12．O（n2）
13．关键字
14．O（n2）
15．散列函数处理冲突的方法
16．查找表
17．桶
三、名词解释
1．顺序表：
把线性表的节点按逻辑次序依次存放在一组地址连续的存储单元里。
2．链队列：
队列的链式存储结构简称为链队列，它是限制仅在表头删除和表尾插入的单链表。
3．行表：
记录稀疏矩阵中每行非零元素在三元表组中的起始位置的表。
4．二叉树：
是一种特殊的树。
在二叉树中，每个节点最多只有两棵子树，并且子树有左右之分。
（它与度数为2的树有区别，在一般树中若某节点只有一个孩子，就无需区分其左右次序，而在二叉树中即使是一个孩子也有左右之分。
）
5．完全图：
图G中任意两个顶点都有一条边相连接，称该图为完全图。
四、简答题
1．头指针是指向链表表头节点的指针，只要链表存在，该指针始终不会改变，已知该指针便已知该链表。
头节点是在链表的开始节点之前附加的一个节点，是链表的表头，当链表不空时，其内的指针指向链表的第一个节点，当链表是空链表时，该指针为空指针。
这样在链表的第一个位置上的操作就和在表的其他位置上操作一样，无须进行特殊处理。
当链表是空链表时，该指针为空指针。
因此空表和非空表的处理也就统一了。
2．栈是先进后出表。
栈的插入和删除都从称为栈顶的一端进行，一般线性表可以在线性表的中间及两端进行插入、删除操作。
3．模式匹配中，所找到的与模式匹配的子串，其开始字符离开目标串首字符的位移称为有效位移。
目标串除有效位移以外，其他字符的位移称为无效位移。
4．
5．［8340，63，13，84，35，96，57，39，79，61，15］
［40，83，13，63，35，84，57，96，39，79，15，61］
［l3，43，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，5761，63，79，83，84，96］
五、应用题
1．node*sum（nodes1,s2）
{
noder,c,*p,*q,*s;
s=（node*）（malloc（sizeof（node））;
r=s;P=s1;q=s2;
while（p!
=null）
{ c=（node*（malloc（size（node））;
c->data=p->data;
r->next=c;
p=p->next;
r=c,
new（c）;
c->data=q->data;
r>next=c;
q=q->next;
r=c;
}
r->next=null;
s=s->next
return（s）;
}
2.voidpassbtree（bstreeroot）
{
if（!
root）return;
if（root->rchild）passbtree（root->rchild）;
printf（root->data）;
if（root->lchild）passbtree（root->lchild）;}
数据结构模拟试题（三）参考答案
一、单项选择题
1．B2．D3．B4．B5．A
6．B7．C8．C9．A10．B
11．C12．C13．C14．D15．B
16．D17．A18．C19．D20．A
二、填空题
l．开始节点2．逻辑
3．顺序表4．head->next＝NULL
5．队尾队首6．34
7．零8．子串的定位运算
9．510．235
11．2m-112．邻接矩阵
13．有向14．快速排序快速排序
15．归并排序16．虚拟存储存取方法B+树
三、名词解释
1．链表的每个节点结构中有两个链域，一个用来存放节点的直接后继的地址，另一个指向其直接前趋。
2．栈的链式存储结构称为链栈，它是运算受限的单链表，其插入和删除操作仅限制在表头位置上进行。
3．若线性表顺序存储的每一个节点均是三元组，则该线性表的存储结构称为三元组表。
4．又称最优二叉树。
它是n个带权叶子节点构成的所有二叉树中带权路径长度WPL最小的二叉树。
5．一条路径上除了开始顶点和结束顶点外,其余顶点均不相同。
四、简答题
1．顺序队列中存在“假上溢”现象。
因为在入队和出队操作中，头尾指针只增加不减少，致使被删元素的空间永远无法重新利用。
因此，尽管队列中实际的元素个数远远小于向量空间的规模，但也可能由于尾指针已超越向量空间的上界而不能做入队操作。
该现象称为“假上溢”。
为充分利用向量空间，克服上述假上溢现象的方法是将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量，存储在其中的队列称为循环队列。
在循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。
只不过当头尾指针指向向量上界时，其加1操作是指向向量的下界。
2．按行优先存储：
Address（aijk）=Address（a000）+[i*m*n+j*n+k]*d
按行优先存储：
Address（aijk）＝Address（a000）+[k*l*m+j*l+i]*d
3．答案：
4．答案：
DFS生成树BFS生成树
5．顺序查找：
表中元素可以任意存放。
查找成功的平均查找长度为（n＋l）/2。
折半查找：
表中元素必须以关键字的值递增或递减的存放且只能以顺序表存放。
查找成功的平均查找长度为log2（n+1）-1。
分块查找：
表中每块内的元素可以任意存放，但块于块之间必须以关键字的值递增或递减的存放，即前一块内所有元素的关键字不能大于（或小于）后一块内任意元素的关键字。
若用顺序表查找确定所在块，平均查找长度为1/2*（n/s+s）＋l。
若用折半查找确定所在块，平均查找长度为log2（n/s+1）+s/2。
五、应用题
l．node*inter（a,b）
node*a,*b;
{
node*p,*q,*r,*s,*c;
c=（node*）malloc（sizeeof（nede））;
r=c;P=a,q=b;
while（p!
=null&&q!
=null）
if（p->datadata）P=P->next;
elseif（p->data>q->data）q=q->next
else{s=（node*）malloc（sizeof（node））;
s->data=p->data;
r->next=s;
r=s;
P=P->next;
q=q->next;
}
r->next=null;
c=c->next;
return（c）;
}
2．Voidoutputleaf（t）
{
if（t!
=0）
{
outputleaf（l[t]）;
outputleaf（r[t]）;
if（l[t]==0&&r[t]==0）if（t%2==0）printf（“%d”,t）;
}
}
数据结构模拟试题（四）参考答案
一、一、单项选择题
1．D2．A3．B4．B5．A
6．B7．B8．B9．C10．B
11．C12．C13．B14．C15．C
16．A17．B18．D19．D20．A
二、填空题
1．数据项
2．逻辑
3．p－＞nexts
4．l
5．后继
6．有效位移
7．＜0
8．顺序链式
9．n＋l
10．4
11．129
12．小或相等
13．O（n2）
14．插入选择
15．右子树
16．索引方法链接方法
三、名词解释
1．是指向链表表头节点的指针，只要链表存在，该指针始终不会改变。
单链表由头指针惟一确定，因此单链表可以用头指针的名字来命名。
2．当栈空的时候，再做退栈运算将产生溢出，简称“下溢”。
下溢常常用来作为程序控制转移的条件。
3．有n个元素a1，a2，…，an组成的有限序列，其中n可以是原子或一个广义表。
4．霍夫曼树中从根到每个叶子节点都有一条惟一的路径，对路径上的各分支约定左分支表示“0”码，右分支表示“l”码，则从根节点到叶子节点的路径上分支的码组成的字符串作为该叶子节点的编码，这就是霍夫曼编码。
5．在无向图G中，若从顶点Vi到Vj有路径，则称Vi和Vj是连通的。
若图G中任意两个顶点都是连通的，则称G为连通图。
四、简答题
1．循环队列中，由于入队时尾指针向前追赶头指针，出队时头指针向前追该尾指针，故队空和队满时头尾指针均相等。
因此，我们无法通过front＝rear来判断队列是“空”还是“满”。
下面三种方法可解决此问题。
其一是另设一布尔变量以区别队列的空和满；其二是少用一个元素的空间，约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：
rear所指的单元始终为空）；其三是使用一个计数器记录队列中元素的总数（实际上是队列长度）。
2．长度：
l
深度：
4
3．
4．深度优先序列：
0231
广度优先序列：
0213
5．答案：
[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]
五、应用题
l．voidlink（vectora,b;intm,n;vectorc）
intI,j,k,t;
I=j=k=l;
while（I<=m&&j<=n）
if（a[I]else{c[k]=b[j];j++;k++;}
if（j==n）for（t=（I+l）;t<=m;t++）{c[k]=a[t];k++;}
if（I==m）for（t=（j+l）;t<=n;t++）{c[k]=b[j];k++;）
}
2．#definen20
#definem30
typdefstruct{intkey;}nodetype;
typdefnodetypesl[m+1];
main（）
{
intI,key,x;
slr;
for（I=0;l{
scanf（"%d",&key）,
r[I].key=key;
}
scanf（"%d",&x）;
insertx（r,x）;
Printf（"outputresult"）,
for（I=0;I{
prinif（"%d",r[I]）;
r[I].key=key;
}
}
voidinsertx（slr,intx）
{
intlow=l,hight=n,mid,pos,I,find=（）;
while（low<=hight）&&!
find）
{
mid=（low+hight）/2,
if（xhight=mid-1;
else
if（x>r[mid]）
low=mid+1;
else
（I=mid;find=1;}
}
if（find）
pos=mid;
else
pos=low;
for（I=1;I>pos;I--）
r[i+1].key=r[i].key;
r[Pos].key=x;
}
数据结构模拟试题（五）参考答案
一、单选题答案
1．D2．B3．A4．A5．B
6．D7．A8．C9．C10．D
ll．C12．D13．A14．B15．C
16．D17．C18．A19．A20．B
二、填空题
1．基本单位2．逻辑关系
3．O（l）O（l）4．栈顶
5．Q－＞front）=Q－＞rear+1
6．顺序存储方式键接存储方式
7．J*（j-1）/2+I8．列数
9．9910．35
11．错误12．Prim
13．O（n2）14．O（n2）
15．堆排序16．相等
17．相同关键字集合中序
三、名词解释
1．在链表的开始节点之前附加的一个节点，是键表的表头，当链表不空时，其内的指针指向链表的第一个节点，当链表是空链表时，该指针为空指针。
2．因为在入队和出队操作中，头尾指针只增加不减少，致使被删元素的空间永远无法重新利用。
因此，尽管队列中实际的元素个数远远小于向量空间的规模，但也可能由于尾指针已超越向量空间的上界而不能做入队操作。
该现象称为“假上溢”。
3．子串的定位运算又称为串的模式匹配。
4．有向边5．两个不同的关键字，其散列函数值相同，因而被映射到同一表位置上的现象称为冲突。
四、简答题
1．栈的顺序存储结构简称为顺序栈，它是运算受限的顺序表。
当栈满的时候，不能进栈，否则将产生上溢。
判断栈满的条件是S－＞top＝Stacksize－l。
当栈空的时候，不能退栈，否则将产生下溢。
判断栈空的条件是S－＞top＜0。
2．线性表是具有相同类型的几个数据元素K0，K1，…，Kn．；的有限序列，记为（K0，K1，…，Kn．）;广义表是n个元素An的有限序列，其中Ai可以是数据元素或表结构，记为A＝（A1，A2，…，An）。
K必须有相同类型，而Ai则可以是数据元素，也可以是表；当广义表每个Ai均是是数据元素且有相同类型时，则它就是一个表,因此,可以说广义表是线性表的一种推广。
3．答案：
（l）djbaechif
（2）abdjcefhi
（3）jdbeihfca
4．答案：
［13，40，63，83，84，35，96，57，39，79，61，15］
［13，15，63，83，84，35，96，57，39，79，61，40］
［13，15，35，83，84，63，96，57，39，79，61，40］
［13，15，35，39，84，63，96，57，83，79，61，40］
［13，15，35，39，40，63，96，57，83，79，61，84］
［13，15，35，39，40，57，96，63，83，79，61，84］
［13，15，35，39，40，57，61，63，83，79，96，84］
［13，15，35，39，40，57，61，63，79，83，96，84］
［13，5，35，39，40，57，61，63，79，83，84，96］
5．
平均长度为4。
五、应用题
1．Intfact（intn）
{
if（n==1）p=1;
if（n!
=1）p=fact（n-1）*n;
elsereturn（p）;
}
fact（3）
fact
（2）
fact
（1）
fact（0）
fact（0）
fact
（1）
fact
（2）
fact（3）
2．
inthighttree（bttree,inth）
{
if（tree==null）h=0;
else
{
highttree（*tree.left.hl）;
highttree（*tree.right,rh）;
if（hl>=hr）h=hl+1;
elseh=hr+1;
}
return（h）;
}
数据结构模拟试题（六）参考答案
一、单选题答案
1．B2．B3．D4．B5．B
6．D7．D8．C9．D10．D
11．B12．D13．B14．A15．B
16．B17．D18．C19．B20．B
二、填空题
1．存储2．起始
3．逻辑4．p－＞nextS
5．栈队列6．2
7．n*（n＋l）/2＋l8．53
9．2k-110．高度或深度
11．递增12．零
13．O（n）14．3
15．O（n）O（log2n）
16．索引顺序存取方法静态
三、名词解释
1．指节点数据本身所占的存储量和整个节点结构所占的存储量之比。
2．当栈满的时候，不能进栈，否则将产生空间溢出，简称“上溢”。
上溢是一种出错状态，应该设法避免。
3．所有非零元素均集中在以主对角线为中心的带状区域的矩阵。
4．在一棵二叉树中，除最底层外，其余层都是满的，并且最底层或者满的或者在右边缺少连续若干个节点。
5．图G由两个集合V和E组成，记为G＝（V，E），其中V是顶点（节点）的有穷非空集合，E是由V中顶点的序偶组成的有穷集，这些序偶称为边。
四、简答题
l．在用头指针表示的单循环链表中，找开始节点a1的时间是O
（1），然而要找到终端节点。
则需从头指针开始遍历整个链表，其时间是O（n）。
在很多实际问题中，表的操作常常是在表的首尾位置上进行，此时头指针表示的单循环链表就显得不够方便。
如果改用尾指针来表示单循环链表，则查找开始节点a1终端节点an都很方便，查找时间都是O（l）。
2．队列的基本运算用以下六种：
Initstake（S）
构造一个空栈S
StakeEmPty（S）
判栈空。
若S为空栈，则返回真值，否则返回假值。
stakeFull（S）
判栈满。
若S为满栈，则返回真值，否则返回假值。
此操作只适用于栈的顺序存储结构。
Push（S，x）
进栈。
若栈S非满，则将元素X插入S的栈顶。
Pop（S）
退栈。
若栈S非满，则删去S的栈顶元素，并返回该元素。
StakeTop（S）
取栈顶元素。
若栈S非空，则返回栈项元素，但不改变栈的状态。
3．答：
链式存储在串的插入和删除操作上效率较高，因为它只需做查找工作，而不需移动后面的元素。
4．
5．性探测再散列的散列表如下图：
查找成功的平均查找长度为ASL＝119（l＊5＋2＋3＋5＋6）＝2.33
五、应用题
l．converts（）
{
chars;
setstack（stack）;
scanf（"%c",&s）,
while（s!
='*'）
{
switch（s）
{
case'（':
{push（stack,s）;scanf（"%c",&s）;break;}
case'）':
{while（（top（stack）1='）'&&!
empty（stack））
{ch=pop（stack）;pintf（“%c”,ch）;}
if（empty（stack））{printf（“%c”,ch）;}
elsech=pop（stack）;
scanf（“%c”,&s）;
升级会员 